Block.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_MEMORY_BLOCK_H__
#define __ROGUE_INTERFACES_MEMORY_BLOCK_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
#include "rogue/interfaces/memory/Master.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
#endif
 
namespace rogue {
namespace interfaces {
namespace memory {
 
#ifndef NO_PYTHON
 
// Template function to convert a python list to a C++ std::vector
template <typename T>
inline std::vector<T> py_list_to_std_vector(const boost::python::object& iterable) {
    return std::vector<T>(boost::python::stl_input_iterator<T>(iterable), boost::python::stl_input_iterator<T>());
}
 
// Template function to convert a c++ std::vector to a python list
template <class T>
inline boost::python::list std_vector_to_py_list(std::vector<T> vector) {
    typename std::vector<T>::iterator iter;
    boost::python::list list;
    for (iter = vector.begin(); iter != vector.end(); ++iter) {
        list.append(*iter);
    }
    return list;
}
 
// Template function to convert a python object to a c++ type with checking
template <typename T>
inline T py_object_convert(const boost::python::object& obj) {
    boost::python::extract<T> ret(obj);
 
    if (!ret.check())
        return (T)0;
    else
        return ret;
}
 
#endif
 
// Forward declaration
class Variable;
 
class Block : public Master {
  protected:
    // Mutex
    std::mutex mtx_;
 
    // Path
    std::string path_;
 
    // Mode
    std::string mode_;
 
    // Bulk Enable
    bool bulkOpEn_;
 
    // Block level update enable
    bool updateEn_;
 
    // Persistant Block Verify Enable
    bool verifyEn_;
 
    // Verify Requred After Write, transiant
    bool verifyReq_;
 
    // Verify transaction in progress
    bool verifyInp_;
 
    // verifyBase byte, transiant
    uint32_t verifyBase_;
 
    // verify Size, transiant
    uint32_t verifySize_;
 
    // Block data
    uint8_t* blockData_;
 
    // Verify data
    uint8_t* verifyData_;
 
    // Verify Mask
    uint8_t* verifyMask_;
 
    // Verify Block
    uint8_t* verifyBlock_;
 
    // Expected data snapshot for verify comparison (captured at write time)
    uint8_t* expectedData_;
 
    // Block size
    uint32_t size_;
 
    // Block offset
    uint64_t offset_;
 
    // Update Flag, transiant
    bool doUpdate_;
 
    // Block python transactions flag
    bool blockPyTrans_;
 
    // Block logging
    std::shared_ptr<rogue::Logging> bLog_;
 
    // Variable list
    std::vector<std::shared_ptr<rogue::interfaces::memory::Variable>> variables_;
 
    // Enable flag
    bool enable_;
 
    // Stale flag
    bool stale_;
 
    // Retry count
    uint32_t retryCount_;
 
#ifndef NO_PYTHON
 
    // Call variable update for all variables
    void varUpdate();
 
#endif
 
    // byte reverse
    static inline void reverseBytes(uint8_t* data, uint32_t byteSize);
 
    // Byte array set/get helpers
 
    // Set data from pointer to internal staged memory
    void setBytes(const uint8_t* data, rogue::interfaces::memory::Variable* var, uint32_t index);
 
    // Get data to pointer from internal block or staged memory
    void getBytes(uint8_t* data, rogue::interfaces::memory::Variable* var, uint32_t index);
 
    // Custom init function called after addVariables
    virtual void customInit();
 
    // Custom cleanup function called before delete
    virtual void customClean();
 
  public:
    static std::shared_ptr<rogue::interfaces::memory::Block> create(uint64_t offset, uint32_t size);
 
    // Setup class for use in python
    static void setup_python();
 
    Block(uint64_t offset, uint32_t size);
 
    // Destroy the Block
    virtual ~Block();
 
    std::string path();
 
    std::string mode();
 
    bool bulkOpEn();
 
    void setEnable(bool enable);
 
    void setLogLevel(uint32_t level) {
        bLog_->setLevel(level);
    }
 
    uint64_t offset();
 
    uint64_t address();
 
    uint32_t size();
 
    bool blockPyTrans();
 
  private:
    void intStartTransaction(uint32_t type,
                             bool forceWr,
                             bool check,
                             rogue::interfaces::memory::Variable* var,
                             int32_t index);
 
  public:
    void startTransaction(uint32_t type,
                          bool forceWr,
                          bool check,
                          rogue::interfaces::memory::Variable* var,
                          int32_t index = -1);
 
#ifndef NO_PYTHON
 
    void startTransactionPy(uint32_t type,
                            bool forceWr,
                            bool check,
                            std::shared_ptr<rogue::interfaces::memory::Variable> var,
                            int32_t index);
 
#endif
 
    bool checkTransaction();
 
#ifndef NO_PYTHON
 
    void checkTransactionPy();
 
#endif
 
    void write(rogue::interfaces::memory::Variable* var, int32_t index = -1);
 
    void read(rogue::interfaces::memory::Variable* var, int32_t index = -1);
 
    void addVariables(std::vector<std::shared_ptr<rogue::interfaces::memory::Variable>> variables);
 
#ifndef NO_PYTHON
 
    void addVariablesPy(boost::python::object variables);
 
#endif
 
    std::vector<std::shared_ptr<rogue::interfaces::memory::Variable>> variables();
 
#ifndef NO_PYTHON
 
    boost::python::object variablesPy();
 
#endif
 
    void rateTest();
 
    // Python functions
 
#ifndef NO_PYTHON
 
    void setPyFunc(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getPyFunc(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    // Raw Bytes
 
#ifndef NO_PYTHON
 
    void setByteArrayPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getByteArrayPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setByteArray(const uint8_t* value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    void getByteArray(uint8_t* value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Unsigned int
 
#ifndef NO_PYTHON
 
    void setUIntPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getUIntPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setUInt(const uint64_t& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    uint64_t getUInt(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Int
 
#ifndef NO_PYTHON
 
    void setIntPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getIntPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setInt(const int64_t& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    int64_t getInt(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Bool
 
#ifndef NO_PYTHON
 
    void setBoolPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getBoolPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setBool(const bool& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    bool getBool(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // String
 
#ifndef NO_PYTHON
 
    void setStringPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getStringPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setString(const std::string& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    std::string getString(rogue::interfaces::memory::Variable* var, int32_t index);
 
    void getString(rogue::interfaces::memory::Variable* var, std::string& valueRet, int32_t index);
 
    void getValue(rogue::interfaces::memory::Variable* var, std::string& valueRet, int32_t index) {
        getString(var, valueRet, index);
    }
 
    // Float
 
#ifndef NO_PYTHON
 
    void setFloatPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getFloatPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setFloat(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getFloat(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Float16 (half-precision)
 
#ifndef NO_PYTHON
 
    void setFloat16Py(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getFloat16Py(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setFloat16(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getFloat16(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Float8 (E4M3)
 
#ifndef NO_PYTHON
 
    void setFloat8Py(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getFloat8Py(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setFloat8(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getFloat8(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // BFloat16 (Brain Float 16)
 
#ifndef NO_PYTHON
 
    void setBFloat16Py(boost::python::object& value,
                       rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getBFloat16Py(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setBFloat16(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getBFloat16(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // TensorFloat32 (NVIDIA TF32)
 
#ifndef NO_PYTHON
 
    void setTensorFloat32Py(boost::python::object& value,
                            rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getTensorFloat32Py(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setTensorFloat32(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getTensorFloat32(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Float6 (E3M2)
 
#ifndef NO_PYTHON
 
    void setFloat6Py(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getFloat6Py(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setFloat6(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getFloat6(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Float4 (E2M1)
 
#ifndef NO_PYTHON
 
    void setFloat4Py(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getFloat4Py(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setFloat4(const float& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    float getFloat4(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Double
 
#ifndef NO_PYTHON
 
    void setDoublePy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getDoublePy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setDouble(const double& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    double getDouble(rogue::interfaces::memory::Variable* var, int32_t index);
 
    // Fixed Point
 
#ifndef NO_PYTHON
 
    void setFixedPy(boost::python::object& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    boost::python::object getFixedPy(rogue::interfaces::memory::Variable* var, int32_t index);
 
#endif
 
    void setFixed(const double& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    double getFixed(rogue::interfaces::memory::Variable* var, int32_t index);
 
    void setUFixed(const double& value, rogue::interfaces::memory::Variable* var, int32_t index);
 
    double getUFixed(rogue::interfaces::memory::Variable* var, int32_t index);
};
 
typedef std::shared_ptr<rogue::interfaces::memory::Block> BlockPtr;
 
}  // namespace memory
}  // namespace interfaces
}  // namespace rogue
 
#endif