22#define NO_IMPORT_ARRAY
24#include <boost/python.hpp>
26namespace bp = boost::python;
65void rim::Block::setup_python() {
66 bp::class_<rim::Block, rim::BlockPtr, bp::bases<rim::Master>, boost::noncopyable>(
"Block",
67 bp::init<uint64_t, uint32_t>())
68 .add_property(
"path", &rim::Block::path)
69 .add_property(
"mode", &rim::Block::mode)
70 .add_property(
"bulkOpEn", &rim::Block::bulkOpEn)
71 .add_property(
"offset", &rim::Block::offset)
72 .add_property(
"address", &rim::Block::address)
73 .add_property(
"size", &rim::Block::size)
74 .def(
"setEnable", &rim::Block::setEnable)
75 .def(
"_startTransaction", &rim::Block::startTransactionPy)
76 .def(
"_checkTransaction", &rim::Block::checkTransactionPy)
77 .def(
"addVariables", &rim::Block::addVariablesPy)
78 .def(
"_rateTest", &rim::Block::rateTest)
79 .add_property(
"variables", &rim::Block::variablesPy);
81 bp::implicitly_convertible<rim::BlockPtr, rim::MasterPtr>();
86rim::Block::Block(uint64_t offset, uint32_t size) {
97 blockPyTrans_ =
false;
105 blockData_ =
reinterpret_cast<uint8_t*
>(malloc(size_));
106 memset(blockData_, 0, size_);
108 verifyData_ =
reinterpret_cast<uint8_t*
>(malloc(size_));
109 memset(verifyData_, 0, size_);
111 verifyMask_ =
reinterpret_cast<uint8_t*
>(malloc(size_));
112 memset(verifyMask_, 0, size_);
114 verifyBlock_ =
reinterpret_cast<uint8_t*
>(malloc(size_));
115 memset(verifyBlock_, 0, size_);
117 expectedData_ =
reinterpret_cast<uint8_t*
>(malloc(size_));
118 memset(expectedData_, 0, size_);
122rim::Block::~Block() {
134std::string rim::Block::path() {
139std::string rim::Block::mode() {
144bool rim::Block::bulkOpEn() {
149void rim::Block::setEnable(
bool newState) {
151 std::lock_guard<std::mutex> lock(mtx_);
156uint64_t rim::Block::offset() {
161uint64_t rim::Block::address() {
162 return (reqAddress() + offset_);
166uint32_t rim::Block::size() {
171bool rim::Block::blockPyTrans() {
172 return blockPyTrans_;
176void rim::Block::intStartTransaction(uint32_t type,
bool forceWr,
rim::Variable* var, int32_t index) {
183 uint32_t minAccess = getSlave()->doMinAccess();
185 std::vector<rim::VariablePtr>::iterator vit;
188 if ((type ==
rim::Write && ((mode_ ==
"RO") || (!stale_ && !forceWr))) || (type ==
rim::Post && (mode_ ==
"RO")) ||
189 (type ==
rim::Read && ((mode_ ==
"WO") || stale_)) ||
190 (type ==
rim::Verify && ((mode_ ==
"WO") || (mode_ ==
"RO") || stale_ || !verifyReq_)))
194 std::lock_guard<std::mutex> lock(mtx_);
201 highByte = size_ - 1;
204 for (vit = variables_.begin(); vit != variables_.end(); ++vit) {
205 (*vit)->stale_ =
false;
227 if (lowByte % minAccess != 0) lowByte -= lowByte % minAccess;
228 if ((highByte + 1) % minAccess != 0) highByte += minAccess - ((highByte + 1) % minAccess);
230 for (vit = variables_.begin(); vit != variables_.end(); ++vit) {
231 if ((*vit)->stale_) {
232 if ((*vit)->staleLowByte_ < lowByte) lowByte = (*vit)->staleLowByte_;
233 if ((*vit)->staleHighByte_ > highByte) highByte = (*vit)->staleHighByte_;
234 (*vit)->stale_ =
false;
241 if (!enable_)
return;
247 tData = verifyData_ + verifyBase_;
254 tSize = (highByte - lowByte) + 1;
257 tData = blockData_ + tOff;
264 verifyReq_ = verifyEn_;
268 memcpy(expectedData_ + tOff, blockData_ + tOff, tSize);
271 doUpdate_ = updateEn_;
273 bLog_->debug(
"Start transaction type = %" PRIu32
", Offset=0x%" PRIx64
", lByte=%" PRIu32
", hByte=%" PRIu32
274 ", tOff=0x%" PRIx32
", tSize=%" PRIu32,
283 reqTransaction(offset_ + tOff, tSize, tData, type);
288void rim::Block::startTransaction(uint32_t type,
bool forceWr,
bool check,
rim::Variable* var, int32_t index) {
296 intStartTransaction(type, fWr, var, index);
299 if (check || retryCount_ > 0) checkTransaction();
305 if ((count + 1) > retryCount_) {
306 bLog_->error(
"Error on try %" PRIu32
" out of %" PRIu32
": %s",
312 bLog_->warning(
"Error on try %" PRIu32
" out of %" PRIu32
": %s",
318 }
while (count++ < retryCount_);
324void rim::Block::startTransactionPy(uint32_t type,
bool forceWr,
bool check,
rim::VariablePtr var, int32_t index) {
329 if (blockPyTrans_)
return;
336 intStartTransaction(type, fWr, var.get(), index);
339 if (check || retryCount_ > 0) upd = checkTransaction();
345 if ((count + 1) > retryCount_) {
346 bLog_->error(
"Error on try %" PRIu32
" out of %" PRIu32
": %s",
352 bLog_->warning(
"Error on try %" PRIu32
" out of %" PRIu32
": %s",
358 }
while (count++ < retryCount_);
360 if (upd) varUpdate();
366bool rim::Block::checkTransaction() {
373 std::lock_guard<std::mutex> lock(mtx_);
381 "Transaction error for block %s with address 0x%.8x. Error %s",
388 if (!enable_)
return false;
392 bLog_->debug(
"Verfying data. Base=0x%" PRIx32
", size=%" PRIu32, verifyBase_, verifySize_);
396 for (x = verifyBase_; x < verifyBase_ + verifySize_; x++) {
397 if ((verifyData_[x] & verifyMask_[x]) != (expectedData_[x] & verifyMask_[x])) {
399 "Verify error for block %s with address 0x%.8" PRIx64
400 ". Byte: %" PRIu32
". Got: 0x%.2" PRIx8
", Exp: 0x%.2" PRIx8
401 ", Mask: 0x%.2" PRIx8,
411 bLog_->debug(
"Transaction complete");
413 locUpdate = doUpdate_;
422void rim::Block::checkTransactionPy() {
423 if (blockPyTrans_)
return;
425 if (checkTransaction()) varUpdate();
432 startTransaction(
rim::Write,
true,
false, var, index);
433 startTransaction(
rim::Verify,
false,
false, var, index);
439 startTransaction(
rim::Read,
false,
false, var, index);
446void rim::Block::varUpdate() {
447 std::vector<rim::VariablePtr>::iterator vit;
451 for (vit = variables_.begin(); vit != variables_.end(); ++vit) {
452 if ((*vit)->updateNotify_) (*vit)->queueUpdate();
459void rim::Block::addVariables(std::vector<rim::VariablePtr> variables) {
460 std::vector<rim::VariablePtr>::iterator vit;
464 uint8_t excMask[size_];
465 uint8_t oleMask[size_];
467 memset(excMask, 0, size_);
468 memset(oleMask, 0, size_);
470 variables_ = variables;
472 for (vit = variables_.begin(); vit != variables_.end(); ++vit) {
473 (*vit)->block_ =
this;
475 if (vit == variables_.begin()) {
476 path_ = (*vit)->path_;
477 std::string logName =
"memory.block." + path_;
479 mode_ = (*vit)->mode_;
482 if ((*vit)->bulkOpEn_) bulkOpEn_ =
true;
483 if ((*vit)->updateNotify_) updateEn_ =
true;
486 if ((*vit)->retryCount_ > retryCount_) retryCount_ = (*vit)->retryCount_;
489 if (mode_ != (*vit)->mode_) mode_ =
"RW";
492 if ((*vit)->numValues_ == 0) {
493 for (x = 0; x < (*vit)->bitOffset_.size(); x++) {
495 if ((*vit)->overlapEn_) {
496 setBits(oleMask, (*vit)->bitOffset_[x], (*vit)->bitSize_[x]);
500 if (anyBits(excMask, (*vit)->bitOffset_[x], (*vit)->bitSize_[x]))
502 "Block::addVariables",
503 "Variable bit overlap detected for block %s with address 0x%.8x and variable %s",
506 (*vit)->name_.c_str()));
508 setBits(excMask, (*vit)->bitOffset_[x], (*vit)->bitSize_[x]);
512 if ((*vit)->mode_ ==
"RW" && (*vit)->verifyEn_) {
514 setBits(verifyMask_, (*vit)->bitOffset_[x], (*vit)->bitSize_[x]);
518 if ((*vit)->mode_ ==
"RO" || (*vit)->mode_ ==
"WO" || !(*vit)->verifyEn_) {
519 setBits(verifyBlock_, (*vit)->bitOffset_[x], (*vit)->bitSize_[x]);
523 "Adding variable %s to block %s at offset 0x%.8x, bitIdx=%i, bitOffset %i, bitSize %i, mode %s, "
526 (*vit)->name_.c_str(),
530 (*vit)->bitOffset_[x],
532 (*vit)->mode_.c_str(),
538 for (x = 0; x < (*vit)->numValues_; x++) {
540 if ((*vit)->overlapEn_) {
541 setBits(oleMask, x * (*vit)->valueStride_ + (*vit)->bitOffset_[0], (*vit)->valueBits_);
545 if (anyBits(excMask, x * (*vit)->valueStride_ + (*vit)->bitOffset_[0], (*vit)->valueBits_))
547 "Block::addVariables",
548 "Variable bit overlap detected for block %s with address 0x%.8x and variable %s",
551 (*vit)->name_.c_str()));
553 setBits(excMask, x * (*vit)->valueStride_ + (*vit)->bitOffset_[0], (*vit)->valueBits_);
557 if ((*vit)->mode_ ==
"RW" && (*vit)->verifyEn_) {
559 setBits(verifyMask_, x * (*vit)->valueStride_ + (*vit)->bitOffset_[0], (*vit)->valueBits_);
563 if ((*vit)->mode_ ==
"RO" || (*vit)->mode_ ==
"WO" || !(*vit)->verifyEn_) {
564 setBits(verifyBlock_, x * (*vit)->valueStride_ + (*vit)->bitOffset_[0], (*vit)->valueBits_);
568 "Adding variable %s to block %s at offset 0x%.8x, index=%i, valueOffset=%i, valueBits %i, mode %s, "
570 (*vit)->name_.c_str(),
574 x * (*vit)->valueStride_ + (*vit)->bitOffset_[0],
576 (*vit)->mode_.c_str(),
583 for (x = 0; x < size_; x++) {
584 if (oleMask[x] & excMask[x])
586 "Variable bit mask overlap detected for block %s with address 0x%.8x",
591 verifyMask_[x] &= (verifyBlock_[x] ^ 0xFF);
598 std::stringstream ss;
599 uint32_t rem = size_;
605 ss <<
"0x" << std::setfill(
'0') << std::hex << std::setw(2) << static_cast<uint32_t>(verifyMask_[x]) <<
" ";
608 if (rem == 0 || x % 10 == 0) {
609 bLog_->debug(
"Done adding variables. Verify Mask %.3i - %.3i: %s", idx, x - 1, ss.str().c_str());
619void rim::Block::addVariablesPy(bp::object variables) {
620 std::vector<rim::VariablePtr> vars = py_list_to_std_vector<rim::VariablePtr>(variables);
627std::vector<rim::VariablePtr> rim::Block::variables() {
634bp::object rim::Block::variablesPy() {
635 return std_vector_to_py_list<rim::VariablePtr>(variables_);
641void rim::Block::reverseBytes(uint8_t* data, uint32_t byteSize) {
645 for (x = 0; x < byteSize / 2; x++) {
647 data[x] = data[byteSize - x - 1];
648 data[byteSize - x - 1] = tmp;
653void rim::Block::setBytes(
const uint8_t* data,
rim::Variable* var, uint32_t index) {
666 std::unique_lock<std::mutex> lock(mtx_, std::try_to_lock);
667 if (!lock.owns_lock()) {
673 if (var->
mode_ !=
"RO") stale_ =
true;
677 buff =
reinterpret_cast<uint8_t*
>(malloc(var->
valueBytes_));
680 "Failed to allocate %" PRIu32
" bytes for byte-reversed copy of %s",
682 var->
name_.c_str()));
686 buff =
const_cast<uint8_t*
>(
reinterpret_cast<const uint8_t*
>(data));
694 "Index %" PRIu32
" is out of range for %s",
696 var->
name_.c_str()));
711 if (var->
mode_ !=
"RO") {
724 if (var->
mode_ !=
"RO") {
738 for (x = 0; x < var->
bitOffset_.size(); x++) {
749void rim::Block::getBytes(uint8_t* data,
rim::Variable* var, uint32_t index) {
757 std::unique_lock<std::mutex> lock(mtx_, std::try_to_lock);
758 if (!lock.owns_lock()) {
767 "Index %" PRIu32
" is out of range for %s",
769 var->
name_.c_str()));
790 for (x = 0; x < var->
bitOffset_.size(); x++) {
810void rim::Block::setPyFunc(bp::object& value,
rim::Variable* var, int32_t index) {
815 if (index == -1) index = 0;
818 if (PyArray_Check(value.ptr())) {
820 "Passing ndarray not supported for %s",
821 var->
name_.c_str()));
824 }
else if (PyList_Check(value.ptr())) {
825 bp::list vl = bp::extract<bp::list>(value);
826 uint32_t vlen = len(vl);
830 "Overflow error for passed array with length %" PRIu32
831 " at index %" PRIu32
". Variable length = %" PRIu32
" for %s",
835 var->
name_.c_str()));
837 for (x = 0; x < vlen; x++) {
841 if (PyObject_GetBuffer(ret.ptr(), &(valueBuf), PyBUF_SIMPLE) < 0)
843 "Failed to extract byte array for %s",
844 var->
name_.c_str()));
846 setBytes(
reinterpret_cast<uint8_t*
>(valueBuf.buf), var, index + x);
847 PyBuffer_Release(&valueBuf);
855 if (PyObject_GetBuffer(ret.ptr(), &(valueBuf), PyBUF_SIMPLE) < 0)
857 "Failed to extract byte array from pyFunc return value for %s",
858 var->
name_.c_str()));
860 setBytes(
reinterpret_cast<uint8_t*
>(valueBuf.buf), var, index);
861 PyBuffer_Release(&valueBuf);
870 if (index < 0 && var->numValues_ > 0) {
872 "Accessing unindexed value not support for %s",
873 var->
name_.c_str()));
879 getBytes(getBuffer, var, index);
880 PyObject* val = Py_BuildValue(
"y#", getBuffer, var->
valueBytes_);
884 bp::handle<> handle(val);
885 bp::object pass = bp::object(handle);
900void rim::Block::setByteArrayPy(bp::object& value,
rim::Variable* var, int32_t index) {
904 if (index < 0 && var->numValues_ > 0)
906 "Accessing unindexed value not supported for %s",
907 var->
name_.c_str()));
909 if (PyObject_GetBuffer(value.ptr(), &(valueBuf), PyBUF_SIMPLE) < 0)
911 "Failed to extract byte array for %s",
912 var->
name_.c_str()));
914 setBytes(
reinterpret_cast<uint8_t*
>(valueBuf.buf), var, index);
915 PyBuffer_Release(&valueBuf);
923 if (index < 0 && var->numValues_ > 0)
925 "Accessing unindexed value not supported for %s",
926 var->
name_.c_str()));
930 getBytes(getBuffer, var, index);
931 PyObject* val = Py_BuildValue(
"y#", getBuffer, var->
valueBytes_);
935 bp::handle<> handle(val);
936 return bp::object(handle);
942void rim::Block::setByteArray(
const uint8_t* value,
rim::Variable* var, int32_t index) {
943 setBytes(value, var, index);
947void rim::Block::getByteArray(uint8_t* value,
rim::Variable* var, int32_t index) {
948 getBytes(value, var, index);
958void rim::Block::setUIntPy(bp::object& value,
rim::Variable* var, int32_t index) {
959 if (index == -1) index = 0;
962 auto process_uint_array = [&](
auto* src, npy_intp stride, npy_intp length) {
963 for (npy_intp i = 0; i < length; ++i) {
964 setUInt(src[i * stride], var, index + i);
969 if (PyArray_Check(value.ptr())) {
971 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(value.ptr());
972 npy_intp ndims = PyArray_NDIM(arr);
973 npy_intp* dims = PyArray_SHAPE(arr);
974 npy_intp* strides = PyArray_STRIDES(arr);
977 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
979 var->
name_.c_str()));
983 "Overflow error for passed array with length %" PRIu32
984 " at index %" PRIu32
". Variable length = %" PRIu32
" for %s",
988 var->
name_.c_str()));
990 int type = PyArray_TYPE(arr);
993 uint64_t* src =
reinterpret_cast<uint64_t*
>(PyArray_DATA(arr));
994 npy_intp stride = strides[0] /
sizeof(uint64_t);
995 process_uint_array(src, stride, dims[0]);
999 uint32_t* src =
reinterpret_cast<uint32_t*
>(PyArray_DATA(arr));
1000 npy_intp stride = strides[0] /
sizeof(uint32_t);
1001 process_uint_array(src, stride, dims[0]);
1005 uint16_t* src =
reinterpret_cast<uint16_t*
>(PyArray_DATA(arr));
1006 npy_intp stride = strides[0] /
sizeof(uint16_t);
1007 process_uint_array(src, stride, dims[0]);
1011 uint8_t* src =
reinterpret_cast<uint8_t*
>(PyArray_DATA(arr));
1012 npy_intp stride = strides[0] /
sizeof(uint8_t);
1013 process_uint_array(src, stride, dims[0]);
1018 "Passed nparray is not of an accepted unsigned int type (uint64, uint32, uint16, uint8) for %s",
1019 var->
name_.c_str()));
1023 }
else if (PyList_Check(value.ptr())) {
1024 bp::list vl = bp::extract<bp::list>(value);
1025 uint32_t vlen = len(vl);
1028 "Overflow error for passed list with length %" PRIu32
1029 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1033 var->
name_.c_str()));
1034 for (uint32_t i = 0; i < vlen; i++) {
1035 bp::extract<uint64_t> tmp(vl[i]);
1038 "Failed to extract value for %s.",
1039 var->
name_.c_str()));
1040 setUInt(tmp, var, index + i);
1044 }
else if (PyArray_CheckScalar(value.ptr())) {
1045 int type_num = PyArray_DescrFromScalar(value.ptr())->type_num;
1049 PyArray_ScalarAsCtype(value.ptr(), &val);
1050 setUInt(val, var, index);
1055 PyArray_ScalarAsCtype(value.ptr(), &val);
1056 setUInt(val, var, index);
1061 PyArray_ScalarAsCtype(value.ptr(), &val);
1062 setUInt(val, var, index);
1067 PyArray_ScalarAsCtype(value.ptr(), &val);
1068 setUInt(val, var, index);
1073 "Failed to extract scalar unsigned int value for %s.",
1074 var->
name_.c_str()));
1077 bp::extract<uint64_t> tmp(value);
1080 setUInt(tmp, var, index);
1089 if (index < 0 && var->numValues_ > 0) {
1097 npType = NPY_UINT16;
1099 npType = NPY_UINT32;
1101 npType = NPY_UINT64;
1104 PyObject* obj = PyArray_SimpleNew(1, dims, npType);
1105 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
1109 uint8_t* dst =
reinterpret_cast<uint8_t*
>(PyArray_DATA(arr));
1111 dst[x] =
static_cast<uint8_t
>(getUInt(var, x));
1116 uint16_t* dst =
reinterpret_cast<uint16_t*
>(PyArray_DATA(arr));
1118 dst[x] =
static_cast<uint16_t
>(getUInt(var, x));
1123 uint32_t* dst =
reinterpret_cast<uint32_t*
>(PyArray_DATA(arr));
1125 dst[x] =
static_cast<uint32_t
>(getUInt(var, x));
1130 uint64_t* dst =
reinterpret_cast<uint64_t*
>(PyArray_DATA(arr));
1132 dst[x] = getUInt(var, x);
1137 boost::python::handle<> handle(obj);
1138 ret = bp::object(handle);
1140 PyObject* val = Py_BuildValue(
"K", getUInt(var, index));
1143 bp::handle<> handle(val);
1144 ret = bp::object(handle);
1152void rim::Block::setUInt(
const uint64_t& val,
rim::Variable* var, int32_t index) {
1156 "Value range error for %s. Value=%" PRIu64
", Min=%f, Max=%f",
1162 setBytes(
reinterpret_cast<uint8_t*
>(
const_cast<uint64_t*
>(&val)), var, index);
1169 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
1181void rim::Block::setIntPy(bp::object& value,
rim::Variable* var, int32_t index) {
1182 if (index == -1) index = 0;
1185 auto process_int_array = [&](
auto* src, npy_intp stride, npy_intp length) {
1186 for (npy_intp i = 0; i < length; ++i) {
1187 setInt(src[i * stride], var, index + i);
1192 if (PyArray_Check(value.ptr())) {
1194 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(value.ptr());
1195 npy_intp ndims = PyArray_NDIM(arr);
1196 npy_intp* dims = PyArray_SHAPE(arr);
1197 npy_intp* strides = PyArray_STRIDES(arr);
1200 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
1202 var->
name_.c_str()));
1206 "Overflow error for passed array with length %" PRIu32
1207 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1211 var->
name_.c_str()));
1213 int type = PyArray_TYPE(arr);
1216 int64_t* src =
reinterpret_cast<int64_t*
>(PyArray_DATA(arr));
1217 npy_intp stride = strides[0] /
sizeof(int64_t);
1218 process_int_array(src, stride, dims[0]);
1222 int32_t* src =
reinterpret_cast<int32_t*
>(PyArray_DATA(arr));
1223 npy_intp stride = strides[0] /
sizeof(int32_t);
1224 process_int_array(src, stride, dims[0]);
1228 int16_t* src =
reinterpret_cast<int16_t*
>(PyArray_DATA(arr));
1229 npy_intp stride = strides[0] /
sizeof(int16_t);
1230 process_int_array(src, stride, dims[0]);
1234 int8_t* src =
reinterpret_cast<int8_t*
>(PyArray_DATA(arr));
1235 npy_intp stride = strides[0] /
sizeof(int8_t);
1236 process_int_array(src, stride, dims[0]);
1241 "Passed nparray is not of an accepted signed int type (int64, int32, int16, int8) for %s",
1242 var->
name_.c_str()));
1246 }
else if (PyList_Check(value.ptr())) {
1247 bp::list vl = bp::extract<bp::list>(value);
1248 uint32_t vlen = len(vl);
1252 "Overflow error for passed list with length %" PRIu32
1253 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1257 var->
name_.c_str()));
1258 for (uint32_t i = 0; i < vlen; i++) {
1259 bp::extract<int64_t> tmp(vl[i]);
1262 "Failed to extract value for %s.",
1263 var->
name_.c_str()));
1264 setInt(tmp, var, index + i);
1268 }
else if (PyArray_CheckScalar(value.ptr())) {
1269 int type_num = PyArray_DescrFromScalar(value.ptr())->type_num;
1273 PyArray_ScalarAsCtype(value.ptr(), &val);
1274 setInt(val, var, index);
1279 PyArray_ScalarAsCtype(value.ptr(), &val);
1280 setInt(val, var, index);
1285 PyArray_ScalarAsCtype(value.ptr(), &val);
1286 setInt(val, var, index);
1291 PyArray_ScalarAsCtype(value.ptr(), &val);
1292 setInt(val, var, index);
1297 "Failed to extract scalar signed int value for %s.",
1298 var->
name_.c_str()));
1301 bp::extract<int64_t> tmp(value);
1305 setInt(tmp, var, index);
1314 if (index < 0 && var->numValues_ > 0) {
1327 PyObject* obj = PyArray_SimpleNew(1, dims, npType);
1328 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
1332 int8_t* dst =
reinterpret_cast<int8_t*
>(PyArray_DATA(arr));
1334 dst[x] =
static_cast<int8_t
>(getInt(var, x));
1339 int16_t* dst =
reinterpret_cast<int16_t*
>(PyArray_DATA(arr));
1341 dst[x] =
static_cast<int16_t
>(getInt(var, x));
1346 int32_t* dst =
reinterpret_cast<int32_t*
>(PyArray_DATA(arr));
1348 dst[x] =
static_cast<int32_t
>(getInt(var, x));
1353 int64_t* dst =
reinterpret_cast<int64_t*
>(PyArray_DATA(arr));
1355 dst[x] = getInt(var, x);
1360 boost::python::handle<> handle(obj);
1361 ret = bp::object(handle);
1363 PyObject* val = Py_BuildValue(
"L", getInt(var, index));
1366 bp::handle<> handle(val);
1367 ret = bp::object(handle);
1379 "Value range error for %s. Value=%" PRId64
", Min=%f, Max=%f",
1386 setBytes(
reinterpret_cast<uint8_t*
>(
const_cast<int64_t*
>(&val)), var, index);
1393 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
1396 if (tmp >=
static_cast<uint64_t
>(pow(2, var->
valueBits_ - 1))) {
1397 tmp -=
static_cast<uint64_t
>(pow(2, var->
valueBits_));
1410void rim::Block::setBoolPy(bp::object& value,
rim::Variable* var, int32_t index) {
1413 if (index == -1) index = 0;
1416 if (PyArray_Check(value.ptr())) {
1418 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
1419 npy_intp ndims = PyArray_NDIM(arr);
1420 npy_intp* dims = PyArray_SHAPE(arr);
1421 npy_intp* strides = PyArray_STRIDES(arr);
1425 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
1427 var->
name_.c_str()));
1431 "Overflow error for passed array with length %" PRIu32
1432 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1436 var->
name_.c_str()));
1438 if (PyArray_TYPE(arr) == NPY_BOOL) {
1439 bool* src =
reinterpret_cast<bool*
>(PyArray_DATA(arr));
1440 npy_intp stride = strides[0] /
sizeof(bool);
1441 for (x = 0; x < dims[0]; x++) {
1442 setBool(src[x * stride], var, index + x);
1446 "Passed nparray is not of type (bool) for %s",
1447 var->
name_.c_str()));
1451 }
else if (PyList_Check(value.ptr())) {
1452 bp::list vl = bp::extract<bp::list>(value);
1453 uint32_t vlen = len(vl);
1457 "Overflow error for passed array with length %" PRIu32
1458 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1462 var->
name_.c_str()));
1464 for (x = 0; x < vlen; x++) {
1465 bp::extract<bool> tmp(vl[x]);
1469 "Failed to extract value for %s.",
1470 var->
name_.c_str()));
1472 setBool(tmp, var, index + x);
1476 }
else if (PyArray_CheckScalar(value.ptr())) {
1477 if (PyArray_DescrFromScalar(value.ptr())->type_num == NPY_BOOL) {
1479 PyArray_ScalarAsCtype(value.ptr(), &val);
1480 setBool(val, var, index);
1486 bp::extract<bool> tmp(value);
1492 setBool(tmp, var, index);
1502 if (index < 0 && var->numValues_ > 0) {
1505 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_BOOL);
1506 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
1507 bool* dst =
reinterpret_cast<bool*
>(PyArray_DATA(arr));
1509 for (x = 0; x < var->
numValues_; x++) dst[x] = getBool(var, x);
1511 boost::python::handle<> handle(obj);
1512 ret = bp::object(handle);
1515 bp::handle<> handle(bp::borrowed(getBool(var, index) ? Py_True : Py_False));
1516 ret = bp::object(handle);
1525 uint8_t val = (uint8_t)value;
1526 setBytes(
reinterpret_cast<uint8_t*
>(&val), var, index);
1533 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
1535 return tmp ? true :
false;
1545void rim::Block::setStringPy(bp::object& value,
rim::Variable* var, int32_t index) {
1550 if (index < 0 && var->numValues_ > 0)
1552 "Using nparray not supported for %s",
1553 var->
name_.c_str()));
1555 bp::extract<char*> tmp(value);
1561 setString(strVal, var, index);
1571 if (index < 0 && var->numValues_ > 0)
1575 getString(var, strVal, index);
1576 PyObject* val = Py_BuildValue(
"s", strVal.c_str());
1580 bp::handle<> handle(val);
1581 return bp::object(handle);
1587void rim::Block::setString(
const std::string& value,
rim::Variable* var, int32_t index) {
1592 strncpy(
reinterpret_cast<char*
>(getBuffer), value.c_str(), var->
valueBytes_ - 1);
1594 setBytes(getBuffer, var, index);
1600 getString(var, ret, index);
1605void rim::Block::getString(
rim::Variable* var, std::string& retString, int32_t index) {
1610 getBytes(
reinterpret_cast<uint8_t*
>(getBuffer), var, index);
1612 retString = getBuffer;
1622void rim::Block::setFloatPy(bp::object& value,
rim::Variable* var, int32_t index) {
1625 if (index == -1) index = 0;
1628 if (PyArray_Check(value.ptr())) {
1630 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
1631 npy_intp ndims = PyArray_NDIM(arr);
1632 npy_intp* dims = PyArray_SHAPE(arr);
1633 npy_intp* strides = PyArray_STRIDES(arr);
1637 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
1639 var->
name_.c_str()));
1643 "Overflow error for passed array with length %" PRIu32
1644 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1648 var->
name_.c_str()));
1650 if (PyArray_TYPE(arr) == NPY_FLOAT32) {
1651 float* src =
reinterpret_cast<float*
>(PyArray_DATA(arr));
1652 npy_intp stride = strides[0] /
sizeof(float);
1653 for (x = 0; x < dims[0]; x++) {
1654 setFloat(src[x * stride], var, index + x);
1658 "Passed nparray is not of type (float32) for %s",
1659 var->
name_.c_str()));
1663 }
else if (PyList_Check(value.ptr())) {
1664 bp::list vl = bp::extract<bp::list>(value);
1665 uint32_t vlen = len(vl);
1669 "Overflow error for passed array with length %" PRIu32
1670 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
1674 var->
name_.c_str()));
1676 for (x = 0; x < vlen; x++) {
1677 bp::extract<float> tmp(vl[x]);
1681 "Failed to extract value for %s.",
1682 var->
name_.c_str()));
1684 setFloat(tmp, var, index + x);
1688 }
else if (PyArray_CheckScalar(value.ptr())) {
1689 if (PyArray_DescrFromScalar(value.ptr())->type_num == NPY_FLOAT32) {
1691 PyArray_ScalarAsCtype(value.ptr(), &val);
1692 setFloat(val, var, index);
1695 "Failed to extract value for %s.",
1696 var->
name_.c_str()));
1699 bp::extract<float> tmp(value);
1703 "Failed to extract value for %s.",
1704 var->
name_.c_str()));
1706 setFloat(tmp, var, index);
1716 if (index < 0 && var->numValues_ > 0) {
1719 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT32);
1720 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
1721 float* dst =
reinterpret_cast<float*
>(PyArray_DATA(arr));
1723 for (x = 0; x < var->
numValues_; x++) dst[x] = getFloat(var, x);
1725 boost::python::handle<> handle(obj);
1726 ret = bp::object(handle);
1729 PyObject* val = Py_BuildValue(
"f", getFloat(var, index));
1733 bp::handle<> handle(val);
1734 ret = bp::object(handle);
1746 "Value range error for %s. Value=%f, Min=%f, Max=%f",
1752 setBytes(
reinterpret_cast<uint8_t*
>(
const_cast<float*
>(&val)), var, index);
1759 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
1767uint16_t floatToHalf(
float value) {
1769 std::memcpy(&f, &value,
sizeof(f));
1771 uint16_t sign = (f >> 16) & 0x8000;
1772 int32_t exponent = ((f >> 23) & 0xFF) - 127 + 15;
1773 uint32_t mantissa = f & 0x7FFFFF;
1775 if (exponent <= 0) {
1776 if (exponent < -10)
return sign;
1777 mantissa |= 0x800000;
1778 uint32_t shift = 14 - exponent;
1779 uint32_t halfMant = mantissa >> shift;
1780 return sign |
static_cast<uint16_t
>(halfMant);
1781 }
else if (exponent == 0xFF - 127 + 15) {
1783 uint16_t halfMantissa =
static_cast<uint16_t
>(mantissa >> 13);
1784 if (halfMantissa == 0) halfMantissa = 0x0001;
1785 return sign | 0x7C00 | halfMantissa;
1787 return sign | 0x7C00;
1788 }
else if (exponent > 30) {
1789 return sign | 0x7C00;
1791 return sign | (exponent << 10) | (mantissa >> 13);
1794float halfToFloat(uint16_t h) {
1795 uint32_t sign = (h & 0x8000) << 16;
1796 uint32_t exponent = (h >> 10) & 0x1F;
1797 uint32_t mantissa = h & 0x3FF;
1800 if (exponent == 0) {
1801 if (mantissa == 0) {
1804 int32_t exponentWork = 1;
1805 while (!(mantissa & 0x400)) {
1810 f = sign | (
static_cast<uint32_t
>(exponentWork + 127 - 15) << 23) | (mantissa << 13);
1812 }
else if (exponent == 31) {
1813 f = sign | 0x7F800000 | (mantissa << 13);
1815 f = sign | ((exponent + 127 - 15) << 23) | (mantissa << 13);
1819 std::memcpy(&result, &f,
sizeof(result));
1823uint8_t floatToFloat8(
float value) {
1825 std::memcpy(&f, &value,
sizeof(f));
1827 uint8_t sign = (f >> 24) & 0x80;
1828 int32_t exponent = ((f >> 23) & 0xFF) - 127 + 7;
1829 uint32_t mantissa = f & 0x7FFFFF;
1832 if (((f >> 23) & 0xFF) == 0xFF && mantissa != 0)
return 0x7F;
1835 if (((f >> 23) & 0xFF) == 0xFF || exponent > 15)
return sign | 0x7E;
1837 if (exponent <= 0) {
1839 if (exponent < -3)
return sign;
1840 mantissa |= 0x800000;
1841 uint32_t shift = 1 - exponent;
1843 return sign | ((mantissa >> 20) & 0x07);
1845 uint8_t mag =
static_cast<uint8_t
>((exponent << 3) | ((mantissa >> 20) & 0x07));
1847 if (mag == 0x7F) mag = 0x7E;
1851float float8ToFloat(uint8_t f8) {
1853 if ((f8 & 0x7F) == 0x7F) {
1854 uint32_t nan = 0x7FC00000;
1856 std::memcpy(&result, &nan,
sizeof(result));
1860 uint32_t sign = (
static_cast<uint32_t
>(f8) & 0x80) << 24;
1861 uint32_t exponent = (f8 >> 3) & 0x0F;
1862 uint32_t mantissa = f8 & 0x07;
1865 if (exponent == 0) {
1866 if (mantissa == 0) {
1871 int32_t exponentWork = 1;
1872 while (!(mantissa & 0x08)) {
1877 f = sign | (
static_cast<uint32_t
>(exponentWork + 127 - 7) << 23) | (mantissa << 20);
1880 f = sign | (
static_cast<uint32_t
>(exponent + 127 - 7) << 23) | (mantissa << 20);
1884 std::memcpy(&result, &f,
sizeof(result));
1888uint16_t floatToBFloat16(
float value) {
1890 std::memcpy(&f, &value,
sizeof(f));
1893 uint16_t bf16 =
static_cast<uint16_t
>(f >> 16);
1895 uint32_t exponent = (f >> 23) & 0xFF;
1896 uint32_t mantissa = f & 0x7FFFFF;
1897 if (exponent == 0xFF && mantissa != 0 && (bf16 & 0x007F) == 0) {
1903float bfloat16ToFloat(uint16_t bf16) {
1904 uint32_t f =
static_cast<uint32_t
>(bf16) << 16;
1906 std::memcpy(&result, &f,
sizeof(result));
1913uint32_t floatToTensorFloat32(
float value) {
1915 std::memcpy(&f, &value,
sizeof(f));
1916 uint32_t tf32 = f & 0xFFFFE000U;
1918 if ((f & 0x7F800000U) == 0x7F800000U && (f & 0x007FFFFFU) != 0 &&
1919 (tf32 & 0x007FFFFFU) == 0) {
1920 tf32 |= 0x00002000U;
1925float tensorFloat32ToFloat(uint32_t tf32) {
1927 std::memcpy(&result, &tf32,
sizeof(result));
1934uint8_t floatToFloat6(
float value) {
1936 std::memcpy(&f, &value,
sizeof(f));
1938 uint8_t sign = (f >> 26) & 0x20;
1939 int32_t exponent = ((f >> 23) & 0xFF) - 127 + 3;
1940 uint32_t mantissa = f & 0x7FFFFF;
1943 if (((f >> 23) & 0xFF) == 0xFF) {
1946 uint8_t nan_sign = (f & 0x7FFFFF) ? 0x00 : static_cast<uint8_t>(sign);
1947 return nan_sign | 0x1F;
1951 if (exponent > 7)
return sign | 0x1F;
1953 if (exponent <= 0) {
1955 if (exponent < -2)
return sign;
1956 mantissa |= 0x800000;
1957 uint32_t shift = 1 - exponent;
1959 return sign | ((mantissa >> 21) & 0x03);
1961 return sign | (exponent << 2) | ((mantissa >> 21) & 0x03);
1964float float6ToFloat(uint8_t f6) {
1968 float sign = (f6 & 0x20) ? -1.0f : 1.0f;
1969 uint32_t exponent = (f6 >> 2) & 0x07;
1970 uint32_t mantissa = f6 & 0x03;
1972 if (exponent == 0) {
1973 if (mantissa == 0) {
1977 return sign *
static_cast<float>(mantissa) * 0.0625f;
1980 float frac = 1.0f +
static_cast<float>(mantissa) / 4.0f;
1981 return sign * std::ldexp(frac,
static_cast<int>(exponent) - 3);
1986uint8_t floatToFloat4(
float value) {
1988 std::memcpy(&f, &value,
sizeof(f));
1990 uint8_t sign = (f >> 28) & 0x08;
1991 int32_t exponent = ((f >> 23) & 0xFF) - 127 + 1;
1992 uint32_t mantissa = f & 0x7FFFFF;
1995 if (((f >> 23) & 0xFF) == 0xFF) {
1998 uint8_t nan_sign = (f & 0x7FFFFF) ? 0x00 : static_cast<uint8_t>(sign);
1999 return nan_sign | 0x07;
2003 if (exponent > 3)
return sign | 0x07;
2005 if (exponent <= 0) {
2007 if (exponent < -1)
return sign;
2008 mantissa |= 0x800000;
2009 uint32_t shift = 1 - exponent;
2011 return sign | ((mantissa >> 22) & 0x01);
2013 return sign | (exponent << 1) | ((mantissa >> 22) & 0x01);
2016float float4ToFloat(uint8_t f4) {
2020 float sign = (f4 & 0x08) ? -1.0f : 1.0f;
2021 uint32_t exponent = (f4 >> 1) & 0x03;
2022 uint32_t mantissa = f4 & 0x01;
2024 if (exponent == 0) {
2025 if (mantissa == 0) {
2029 return sign *
static_cast<float>(mantissa) * 0.5f;
2032 float frac = 1.0f +
static_cast<float>(mantissa) / 2.0f;
2033 return sign * std::ldexp(frac,
static_cast<int>(exponent) - 1);
2045void rim::Block::setFloat16Py(bp::object& value,
rim::Variable* var, int32_t index) {
2048 if (index == -1) index = 0;
2051 if (PyArray_Check(value.ptr())) {
2053 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2054 npy_intp ndims = PyArray_NDIM(arr);
2055 npy_intp* dims = PyArray_SHAPE(arr);
2056 npy_intp* strides = PyArray_STRIDES(arr);
2060 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2062 var->
name_.c_str()));
2066 "Overflow error for passed array with length %" PRIu32
2067 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2071 var->
name_.c_str()));
2073 if (PyArray_TYPE(arr) == NPY_HALF) {
2074 npy_half* src =
reinterpret_cast<npy_half*
>(PyArray_DATA(arr));
2075 npy_intp stride = strides[0] /
sizeof(npy_half);
2076 for (x = 0; x < dims[0]; x++) {
2077 float val = halfToFloat(src[x * stride]);
2078 setFloat16(val, var, index + x);
2082 "Passed nparray is not of type (float16) for %s",
2083 var->
name_.c_str()));
2087 }
else if (PyList_Check(value.ptr())) {
2088 bp::list vl = bp::extract<bp::list>(value);
2089 uint32_t vlen = len(vl);
2093 "Overflow error for passed array with length %" PRIu32
2094 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2098 var->
name_.c_str()));
2100 for (x = 0; x < vlen; x++) {
2101 bp::extract<float> tmp(vl[x]);
2105 "Failed to extract value for %s.",
2106 var->
name_.c_str()));
2108 setFloat16(tmp, var, index + x);
2112 }
else if (PyArray_CheckScalar(value.ptr())) {
2113 if (PyArray_DescrFromScalar(value.ptr())->type_num == NPY_HALF) {
2115 PyArray_ScalarAsCtype(value.ptr(), &val);
2116 float fval = halfToFloat(val);
2117 setFloat16(fval, var, index);
2120 "Failed to extract value for %s.",
2121 var->
name_.c_str()));
2124 bp::extract<float> tmp(value);
2128 "Failed to extract value for %s.",
2129 var->
name_.c_str()));
2131 setFloat16(tmp, var, index);
2141 if (index < 0 && var->numValues_ > 0) {
2144 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_HALF);
2145 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2146 npy_half* dst =
reinterpret_cast<npy_half*
>(PyArray_DATA(arr));
2148 for (x = 0; x < var->
numValues_; x++) dst[x] = floatToHalf(getFloat16(var, x));
2150 boost::python::handle<> handle(obj);
2151 ret = bp::object(handle);
2154 PyObject* val = Py_BuildValue(
"f", getFloat16(var, index));
2158 bp::handle<> handle(val);
2159 ret = bp::object(handle);
2167void rim::Block::setFloat16(
const float& val,
rim::Variable* var, int32_t index) {
2171 "Value range error for %s. Value=%f, Min=%f, Max=%f",
2178 uint16_t half = floatToHalf(val);
2179 setBytes(
reinterpret_cast<uint8_t*
>(&half), var, index);
2186 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
2188 return halfToFloat(tmp);
2198void rim::Block::setFloat8Py(bp::object& value,
rim::Variable* var, int32_t index) {
2201 if (index == -1) index = 0;
2204 if (PyArray_Check(value.ptr())) {
2206 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2207 npy_intp ndims = PyArray_NDIM(arr);
2208 npy_intp* dims = PyArray_SHAPE(arr);
2209 npy_intp* strides = PyArray_STRIDES(arr);
2213 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2215 var->
name_.c_str()));
2219 "Overflow error for passed array with length %" PRIu32
2220 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2224 var->
name_.c_str()));
2226 if (PyArray_TYPE(arr) == NPY_FLOAT) {
2227 float* src =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2228 npy_intp stride = strides[0] /
sizeof(float);
2229 for (x = 0; x < dims[0]; x++) {
2230 float val = src[x * stride];
2231 setFloat8(val, var, index + x);
2235 "Passed nparray is not of type (float32) for %s",
2236 var->
name_.c_str()));
2240 }
else if (PyList_Check(value.ptr())) {
2241 bp::list vl = bp::extract<bp::list>(value);
2242 uint32_t vlen = len(vl);
2246 "Overflow error for passed array with length %" PRIu32
2247 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2251 var->
name_.c_str()));
2253 for (x = 0; x < vlen; x++) {
2254 bp::extract<float> tmp(vl[x]);
2258 "Failed to extract value for %s.",
2259 var->
name_.c_str()));
2261 setFloat8(tmp, var, index + x);
2265 bp::extract<float> tmp(value);
2269 "Failed to extract value for %s.",
2270 var->
name_.c_str()));
2272 setFloat8(tmp, var, index);
2282 if (index < 0 && var->numValues_ > 0) {
2284 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT);
2285 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2286 float* dst =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2288 for (x = 0; x < var->
numValues_; x++) dst[x] = getFloat8(var, x);
2290 boost::python::handle<> handle(obj);
2291 ret = bp::object(handle);
2294 PyObject* val = Py_BuildValue(
"f", getFloat8(var, index));
2298 bp::handle<> handle(val);
2299 ret = bp::object(handle);
2307void rim::Block::setFloat8(
const float& val,
rim::Variable* var, int32_t index) {
2311 "Value range error for %s. Value=%f, Min=%f, Max=%f",
2318 uint8_t f8 = floatToFloat8(val);
2319 setBytes(
reinterpret_cast<uint8_t*
>(&f8), var, index);
2326 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
2328 return float8ToFloat(tmp);
2338void rim::Block::setBFloat16Py(bp::object& value,
rim::Variable* var, int32_t index) {
2341 if (index == -1) index = 0;
2344 if (PyArray_Check(value.ptr())) {
2346 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2347 npy_intp ndims = PyArray_NDIM(arr);
2348 npy_intp* dims = PyArray_SHAPE(arr);
2349 npy_intp* strides = PyArray_STRIDES(arr);
2353 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2355 var->
name_.c_str()));
2359 "Overflow error for passed array with length %" PRIu32
2360 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2364 var->
name_.c_str()));
2366 if (PyArray_TYPE(arr) == NPY_FLOAT) {
2367 float* src =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2368 npy_intp stride = strides[0] /
sizeof(float);
2369 for (x = 0; x < dims[0]; x++) {
2370 float val = src[x * stride];
2371 setBFloat16(val, var, index + x);
2375 "Passed nparray is not of type (float32) for %s",
2376 var->
name_.c_str()));
2380 }
else if (PyList_Check(value.ptr())) {
2381 bp::list vl = bp::extract<bp::list>(value);
2382 uint32_t vlen = len(vl);
2386 "Overflow error for passed array with length %" PRIu32
2387 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2391 var->
name_.c_str()));
2393 for (x = 0; x < vlen; x++) {
2394 bp::extract<float> tmp(vl[x]);
2398 "Failed to extract value for %s.",
2399 var->
name_.c_str()));
2401 setBFloat16(tmp, var, index + x);
2405 bp::extract<float> tmp(value);
2409 "Failed to extract value for %s.",
2410 var->
name_.c_str()));
2412 setBFloat16(tmp, var, index);
2422 if (index < 0 && var->numValues_ > 0) {
2424 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT);
2425 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2426 float* dst =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2428 for (x = 0; x < var->
numValues_; x++) dst[x] = getBFloat16(var, x);
2430 boost::python::handle<> handle(obj);
2431 ret = bp::object(handle);
2434 PyObject* val = Py_BuildValue(
"f", getBFloat16(var, index));
2438 bp::handle<> handle(val);
2439 ret = bp::object(handle);
2447void rim::Block::setBFloat16(
const float& val,
rim::Variable* var, int32_t index) {
2451 "Value range error for %s. Value=%f, Min=%f, Max=%f",
2458 uint16_t bf16 = floatToBFloat16(val);
2459 setBytes(
reinterpret_cast<uint8_t*
>(&bf16), var, index);
2466 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
2468 return bfloat16ToFloat(tmp);
2478void rim::Block::setTensorFloat32Py(bp::object& value,
rim::Variable* var, int32_t index) {
2481 if (index == -1) index = 0;
2484 if (PyArray_Check(value.ptr())) {
2486 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2487 npy_intp ndims = PyArray_NDIM(arr);
2488 npy_intp* dims = PyArray_SHAPE(arr);
2489 npy_intp* strides = PyArray_STRIDES(arr);
2493 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2495 var->
name_.c_str()));
2499 "Overflow error for passed array with length %" PRIu32
2500 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2504 var->
name_.c_str()));
2506 if (PyArray_TYPE(arr) == NPY_FLOAT) {
2507 float* src =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2508 npy_intp stride = strides[0] /
sizeof(float);
2509 for (x = 0; x < dims[0]; x++) {
2510 float val = src[x * stride];
2511 setTensorFloat32(val, var, index + x);
2515 "Passed nparray is not of type (float32) for %s",
2516 var->
name_.c_str()));
2520 }
else if (PyList_Check(value.ptr())) {
2521 bp::list vl = bp::extract<bp::list>(value);
2522 uint32_t vlen = len(vl);
2526 "Overflow error for passed array with length %" PRIu32
2527 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2531 var->
name_.c_str()));
2533 for (x = 0; x < vlen; x++) {
2534 bp::extract<float> tmp(vl[x]);
2538 "Failed to extract value for %s.",
2539 var->
name_.c_str()));
2541 setTensorFloat32(tmp, var, index + x);
2545 bp::extract<float> tmp(value);
2549 "Failed to extract value for %s.",
2550 var->
name_.c_str()));
2552 setTensorFloat32(tmp, var, index);
2562 if (index < 0 && var->numValues_ > 0) {
2564 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT);
2565 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2566 float* dst =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2568 for (x = 0; x < var->
numValues_; x++) dst[x] = getTensorFloat32(var, x);
2570 boost::python::handle<> handle(obj);
2571 ret = bp::object(handle);
2574 PyObject* val = Py_BuildValue(
"f", getTensorFloat32(var, index));
2578 bp::handle<> handle(val);
2579 ret = bp::object(handle);
2587void rim::Block::setTensorFloat32(
const float& val,
rim::Variable* var, int32_t index) {
2591 "Value range error for %s. Value=%f, Min=%f, Max=%f",
2598 uint32_t tf32 = floatToTensorFloat32(val);
2599 setBytes(
reinterpret_cast<uint8_t*
>(&tf32), var, index);
2606 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
2608 return tensorFloat32ToFloat(tmp);
2618void rim::Block::setFloat6Py(bp::object& value,
rim::Variable* var, int32_t index) {
2621 if (index == -1) index = 0;
2624 if (PyArray_Check(value.ptr())) {
2626 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2627 npy_intp ndims = PyArray_NDIM(arr);
2628 npy_intp* dims = PyArray_SHAPE(arr);
2629 npy_intp* strides = PyArray_STRIDES(arr);
2633 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2635 var->
name_.c_str()));
2639 "Overflow error for passed array with length %" PRIu32
2640 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2644 var->
name_.c_str()));
2646 if (PyArray_TYPE(arr) == NPY_FLOAT) {
2647 float* src =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2648 npy_intp stride = strides[0] /
sizeof(float);
2649 for (x = 0; x < dims[0]; x++) {
2650 float val = src[x * stride];
2651 setFloat6(val, var, index + x);
2655 "Passed nparray is not of type (float32) for %s",
2656 var->
name_.c_str()));
2660 }
else if (PyList_Check(value.ptr())) {
2661 bp::list vl = bp::extract<bp::list>(value);
2662 uint32_t vlen = len(vl);
2666 "Overflow error for passed array with length %" PRIu32
2667 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2671 var->
name_.c_str()));
2673 for (x = 0; x < vlen; x++) {
2674 bp::extract<float> tmp(vl[x]);
2678 "Failed to extract value for %s.",
2679 var->
name_.c_str()));
2681 setFloat6(tmp, var, index + x);
2685 bp::extract<float> tmp(value);
2689 "Failed to extract value for %s.",
2690 var->
name_.c_str()));
2692 setFloat6(tmp, var, index);
2702 if (index < 0 && var->numValues_ > 0) {
2704 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT);
2705 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2706 float* dst =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2708 for (x = 0; x < var->
numValues_; x++) dst[x] = getFloat6(var, x);
2710 boost::python::handle<> handle(obj);
2711 ret = bp::object(handle);
2714 PyObject* val = Py_BuildValue(
"f", getFloat6(var, index));
2718 bp::handle<> handle(val);
2719 ret = bp::object(handle);
2727void rim::Block::setFloat6(
const float& val,
rim::Variable* var, int32_t index) {
2731 "Value range error for %s. Value=%f, Min=%f, Max=%f",
2738 uint8_t f6 = floatToFloat6(val);
2739 setBytes(
reinterpret_cast<uint8_t*
>(&f6), var, index);
2746 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
2748 return float6ToFloat(tmp);
2758void rim::Block::setFloat4Py(bp::object& value,
rim::Variable* var, int32_t index) {
2761 if (index == -1) index = 0;
2764 if (PyArray_Check(value.ptr())) {
2766 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2767 npy_intp ndims = PyArray_NDIM(arr);
2768 npy_intp* dims = PyArray_SHAPE(arr);
2769 npy_intp* strides = PyArray_STRIDES(arr);
2773 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2775 var->
name_.c_str()));
2779 "Overflow error for passed array with length %" PRIu32
2780 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2784 var->
name_.c_str()));
2786 if (PyArray_TYPE(arr) == NPY_FLOAT) {
2787 float* src =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2788 npy_intp stride = strides[0] /
sizeof(float);
2789 for (x = 0; x < dims[0]; x++) {
2790 float val = src[x * stride];
2791 setFloat4(val, var, index + x);
2795 "Passed nparray is not of type (float32) for %s",
2796 var->
name_.c_str()));
2800 }
else if (PyList_Check(value.ptr())) {
2801 bp::list vl = bp::extract<bp::list>(value);
2802 uint32_t vlen = len(vl);
2806 "Overflow error for passed array with length %" PRIu32
2807 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2811 var->
name_.c_str()));
2813 for (x = 0; x < vlen; x++) {
2814 bp::extract<float> tmp(vl[x]);
2818 "Failed to extract value for %s.",
2819 var->
name_.c_str()));
2821 setFloat4(tmp, var, index + x);
2825 bp::extract<float> tmp(value);
2829 "Failed to extract value for %s.",
2830 var->
name_.c_str()));
2832 setFloat4(tmp, var, index);
2842 if (index < 0 && var->numValues_ > 0) {
2844 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT);
2845 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2846 float* dst =
reinterpret_cast<float*
>(PyArray_DATA(arr));
2848 for (x = 0; x < var->
numValues_; x++) dst[x] = getFloat4(var, x);
2850 boost::python::handle<> handle(obj);
2851 ret = bp::object(handle);
2854 PyObject* val = Py_BuildValue(
"f", getFloat4(var, index));
2858 bp::handle<> handle(val);
2859 ret = bp::object(handle);
2867void rim::Block::setFloat4(
const float& val,
rim::Variable* var, int32_t index) {
2871 "Value range error for %s. Value=%f, Min=%f, Max=%f",
2878 uint8_t f4 = floatToFloat4(val);
2879 setBytes(
reinterpret_cast<uint8_t*
>(&f4), var, index);
2886 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
2888 return float4ToFloat(tmp);
2898void rim::Block::setDoublePy(bp::object& value,
rim::Variable* var, int32_t index) {
2901 if (index == -1) index = 0;
2904 if (PyArray_Check(value.ptr())) {
2906 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
2907 npy_intp ndims = PyArray_NDIM(arr);
2908 npy_intp* dims = PyArray_SHAPE(arr);
2909 npy_intp* strides = PyArray_STRIDES(arr);
2913 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
2915 var->
name_.c_str()));
2919 "Overflow error for passed array with length %" PRIu32
2920 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2924 var->
name_.c_str()));
2926 if (PyArray_TYPE(arr) == NPY_FLOAT64) {
2927 double* src =
reinterpret_cast<double*
>(PyArray_DATA(arr));
2928 npy_intp stride = strides[0] /
sizeof(double);
2929 for (x = 0; x < dims[0]; x++) {
2930 setDouble(src[x * stride], var, index + x);
2934 "Passed nparray is not of type (double) for %s",
2935 var->
name_.c_str()));
2939 }
else if (PyList_Check(value.ptr())) {
2940 bp::list vl = bp::extract<bp::list>(value);
2941 uint32_t vlen = len(vl);
2945 "Overflow error for passed array with length %" PRIu32
2946 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
2950 var->
name_.c_str()));
2952 for (x = 0; x < vlen; x++) {
2953 bp::extract<double> tmp(vl[x]);
2957 "Failed to extract value for %s.",
2958 var->
name_.c_str()));
2960 setDouble(tmp, var, index + x);
2964 }
else if (PyArray_CheckScalar(value.ptr())) {
2965 if (PyArray_DescrFromScalar(value.ptr())->type_num == NPY_FLOAT64) {
2967 PyArray_ScalarAsCtype(value.ptr(), &val);
2968 setDouble(val, var, index);
2971 "Failed to extract value for %s.",
2972 var->
name_.c_str()));
2975 bp::extract<double> tmp(value);
2979 "Failed to extract value for %s.",
2980 var->
name_.c_str()));
2982 setDouble(tmp, var, index);
2992 if (index < 0 && var->numValues_ > 0) {
2995 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT64);
2996 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
2997 double* dst =
reinterpret_cast<double*
>(PyArray_DATA(arr));
2999 for (x = 0; x < var->
numValues_; x++) dst[x] = getDouble(var, x);
3001 boost::python::handle<> handle(obj);
3002 ret = bp::object(handle);
3005 PyObject* val = Py_BuildValue(
"d", getDouble(var, index));
3009 bp::handle<> handle(val);
3010 ret = bp::object(handle);
3018void rim::Block::setDouble(
const double& val,
rim::Variable* var, int32_t index) {
3022 "Value range error for %s. Value=%f, Min=%f, Max=%f",
3028 setBytes(
reinterpret_cast<uint8_t*
>(
const_cast<double*
>(&val)), var, index);
3035 getBytes(
reinterpret_cast<uint8_t*
>(&tmp), var, index);
3047void rim::Block::setFixedPy(bp::object& value,
rim::Variable* var, int32_t index) {
3051 auto setScalar = [
this, var](
const double& v, int32_t idx) {
3053 setUFixed(v, var, idx);
3055 setFixed(v, var, idx);
3058 if (index == -1) index = 0;
3061 if (PyArray_Check(value.ptr())) {
3063 PyArrayObject* arr =
reinterpret_cast<decltype(arr)
>(value.ptr());
3064 npy_intp ndims = PyArray_NDIM(arr);
3065 npy_intp* dims = PyArray_SHAPE(arr);
3066 npy_intp* strides = PyArray_STRIDES(arr);
3070 "Invalid number of dimensions (%" PRIu32
") for passed ndarray for %s",
3072 var->
name_.c_str()));
3076 "Overflow error for passed array with length %" PRIu32
3077 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
3081 var->
name_.c_str()));
3083 if (PyArray_TYPE(arr) == NPY_FLOAT64) {
3084 double* src =
reinterpret_cast<double*
>(PyArray_DATA(arr));
3085 npy_intp stride = strides[0] /
sizeof(double);
3086 for (x = 0; x < dims[0]; x++) {
3087 setScalar(src[x * stride], index + x);
3091 "Passed nparray is not of type (double) for %s",
3092 var->
name_.c_str()));
3096 }
else if (PyList_Check(value.ptr())) {
3097 bp::list vl = bp::extract<bp::list>(value);
3098 uint32_t vlen = len(vl);
3102 "Overflow error for passed array with length %" PRIu32
3103 " at index %" PRIi32
". Variable length = %" PRIu32
" for %s",
3107 var->
name_.c_str()));
3109 for (x = 0; x < vlen; x++) {
3110 bp::extract<double> tmp(vl[x]);
3114 "Failed to extract value for %s.",
3115 var->
name_.c_str()));
3117 setScalar(tmp, index + x);
3121 }
else if (PyArray_CheckScalar(value.ptr())) {
3122 if (PyArray_DescrFromScalar(value.ptr())->type_num == NPY_FLOAT64) {
3124 PyArray_ScalarAsCtype(value.ptr(), &val);
3125 setScalar(val, index);
3128 "Failed to extract value for %s.",
3129 var->
name_.c_str()));
3132 bp::extract<double> tmp(value);
3136 "Failed to extract value for %s.",
3137 var->
name_.c_str()));
3139 setScalar(tmp, index);
3149 auto getScalar = [
this, var](int32_t idx) ->
double {
3154 if (index < 0 && var->numValues_ > 0) {
3157 PyObject* obj = PyArray_SimpleNew(1, dims, NPY_FLOAT64);
3158 PyArrayObject* arr =
reinterpret_cast<PyArrayObject*
>(obj);
3159 double* dst =
reinterpret_cast<double*
>(PyArray_DATA(arr));
3161 for (x = 0; x < var->
numValues_; x++) dst[x] = getScalar(x);
3163 boost::python::handle<> handle(obj);
3164 ret = bp::object(handle);
3167 PyObject* val = Py_BuildValue(
"d", getScalar(index));
3171 bp::handle<> handle(val);
3172 ret = bp::object(handle);
3180void rim::Block::setFixed(
const double& val,
rim::Variable* var, int32_t index) {
3184 "Value range error for %s. Value=%f, Min=%f, Max=%f",
3191 int64_t fPoint =
static_cast<int64_t
>(round(val * pow(2, var->
binPoint_)));
3194 int64_t maxInt =
static_cast<int64_t
>((1ULL << (var->
valueBits_ - 1)) - 1);
3195 int64_t minInt = -maxInt - 1;
3198 if (fPoint > maxInt || fPoint < minInt)
3200 "Fixed point overflow for %s. Value=%f, Min=%f, Max=%f",
3203 static_cast<double>(minInt) / pow(2, var->
binPoint_),
3204 static_cast<double>(maxInt) / pow(2, var->
binPoint_)));
3206 setBytes(
reinterpret_cast<uint8_t*
>(&fPoint), var, index);
3214 getBytes(
reinterpret_cast<uint8_t*
>(&fPoint), var, index);
3219 const int64_t signBit = 1LL << (var->
valueBits_ - 1);
3220 const int64_t modulus = 1LL << var->
valueBits_;
3221 if ((fPoint & signBit) != 0) fPoint -= modulus;
3225 tmp =
static_cast<double>(fPoint);
3231void rim::Block::setUFixed(
const double& val,
rim::Variable* var, int32_t index) {
3235 "Value range error for %s. Value=%f, Min=%f, Max=%f",
3244 "Unsigned fixed-point underflow for %s. Value=%f",
3248 uint64_t fPoint =
static_cast<uint64_t
>(round(val * pow(2, var->
binPoint_)));
3255 if (fPoint > maxUInt)
3257 "Unsigned fixed-point overflow for %s. Value=%f, Min=0, Max=%f",
3260 static_cast<double>(maxUInt) / pow(2, var->
binPoint_)));
3262 setBytes(
reinterpret_cast<uint8_t*
>(&fPoint), var, index);
3267 uint64_t fPoint = 0;
3269 getBytes(
reinterpret_cast<uint8_t*
>(&fPoint), var, index);
3271 return static_cast<double>(fPoint) / pow(2, var->
binPoint_);
3279void rim::Block::customInit() {}
3282void rim::Block::customClean() {}
3284void rim::Block::rateTest() {
3287 struct timeval stime;
3288 struct timeval etime;
3289 struct timeval dtime;
3291 uint64_t count = 1000000;
3296 gettimeofday(&stime, NULL);
3298 for (x = 0; x < count; ++x) {
3299 reqTransaction(0, 4, &value,
rim::Read);
3302 gettimeofday(&etime, NULL);
3304 timersub(&etime, &stime, &dtime);
3305 durr = dtime.tv_sec +
static_cast<float>(dtime.tv_usec) / 1.0e6;
3306 rate = count / durr;
3308 printf(
"\nBlock c++ raw: Read %" PRIu64
" times in %f seconds. Rate = %f\n", count, durr, rate);
3310 gettimeofday(&stime, NULL);
3312 for (x = 0; x < count; ++x) {
3313 reqTransaction(0, 4,
reinterpret_cast<uint8_t*
>(&count),
rim::Write);
3316 gettimeofday(&etime, NULL);
3318 timersub(&etime, &stime, &dtime);
3319 durr = dtime.tv_sec +
static_cast<float>(dtime.tv_usec) / 1.0e6;
3320 rate = count / durr;
3322 printf(
"\nBlock c++ raw: Wrote %" PRIu64
" times in %f seconds. Rate = %f\n", count, durr, rate);
Generic Rogue exception type.
char const * what() const
Returns exception text for standard exception handling.
static GeneralError create(std::string src, const char *fmt,...)
Creates a formatted error instance.
RAII helper that releases the Python GIL for a scope.
static std::shared_ptr< rogue::Logging > create(const std::string &name, bool quiet=false)
Creates a logger instance.
RAII helper that acquires the Python GIL for a scope.
uint32_t size()
Returns block size in bytes.
uint64_t offset()
Returns the local offset of this block.
Internal Boost.Python wrapper for rogue::interfaces::memory::Variable. Enables Python subclasses to o...
Memory variable descriptor and typed accessor facade.
std::vector< uint32_t > bitSize_
std::vector< uint32_t > bitOffset_
std::shared_ptr< rogue::interfaces::memory::Block > BlockPtr
Shared pointer alias for Block.
static const uint32_t Read
Memory read transaction type.
static const uint32_t Write
Memory write transaction type.
static const uint32_t Verify
Memory verify readback transaction type.
static const uint8_t UFixed
Block access type for unsigned fixed-point numeric data.
static const uint32_t Post
Memory posted write transaction type.
std::shared_ptr< rogue::interfaces::memory::Variable > VariablePtr