rogue
Loading...
Searching...
No Matches
Hub.cpp
Go to the documentation of this file.
1
19#include "rogue/Directives.h"
20
22
23#include <inttypes.h>
24
25#include <cmath>
26#include <memory>
27#include <string>
28#include <vector>
29
30#include "rogue/GilRelease.h"
31#include "rogue/ScopedGil.h"
33
35
36#ifndef NO_PYTHON
37 #include <boost/python.hpp>
38namespace bp = boost::python;
39#endif
40
42rim::HubPtr rim::Hub::create(uint64_t offset, uint32_t min, uint32_t max) {
43 rim::HubPtr b = std::make_shared<rim::Hub>(offset, min, max);
44 return (b);
45}
46
48rim::Hub::Hub(uint64_t offset, uint32_t min, uint32_t max) : Master(), Slave(min, max) {
49 offset_ = offset;
50 root_ = (min != 0 && max != 0);
51 log_ = rogue::Logging::create("memory.Hub");
52}
53
55rim::Hub::~Hub() {}
56
58uint64_t rim::Hub::getOffset() {
59 return offset_;
60}
61
63uint64_t rim::Hub::getAddress() {
64 return (reqAddress() + offset_);
65}
66
68uint32_t rim::Hub::doSlaveId() {
69 if (root_)
70 return (rim::Slave::doSlaveId());
71 else
72 return (reqSlaveId());
73}
74
76std::string rim::Hub::doSlaveName() {
77 if (root_)
78 return (rim::Slave::doSlaveName());
79 else
80 return (reqSlaveName());
81}
82
84uint32_t rim::Hub::doMinAccess() {
85 if (root_)
86 return (rim::Slave::doMinAccess());
87 else
88 return (reqMinAccess());
89}
90
92uint32_t rim::Hub::doMaxAccess() {
93 // Transaction splitting allows for "unlimited" max access
94 if (root_)
95 return (rim::Slave::doMaxAccess());
96 else
97 return 0xFFFFFFFF;
98}
99
101uint64_t rim::Hub::doAddress() {
102 if (root_)
103 return (0);
104 else
105 return (reqAddress() + offset_);
106}
107
109void rim::Hub::doTransaction(rim::TransactionPtr tran) {
110 uint32_t maxAccess = getSlave()->doMaxAccess();
111
112 // Adjust address
113 tran->address_ += offset_;
114
115 // Split into smaller transactions if necessary. A maxAccess of 0 (e.g. the
116 // unconnected placeholder slave) has no limit to split against, so forward
117 // the transaction and let the slave report.
118 if (maxAccess != 0 && tran->size() > maxAccess) {
119 uint32_t numberOfTransactions = std::ceil(1.0 * tran->size() / maxAccess);
120 std::vector<rim::TransactionPtr> subTransactions;
121 subTransactions.reserve(numberOfTransactions);
122
123 log_->debug("Splitting transaction %" PRIu32 " into %" PRIu32 " subtransactions",
124 tran->id_,
125 numberOfTransactions);
126
127 for (unsigned int i = 0; i < numberOfTransactions; ++i) {
128 rim::TransactionPtr subTran = tran->createSubTransaction();
129 subTran->iter_ = reinterpret_cast<uint8_t*>(tran->begin() + i * maxAccess);
130 if (tran->size() >= ((i + 1) * maxAccess)) {
131 subTran->size_ = maxAccess;
132 } else {
133 subTran->size_ = tran->size() % maxAccess;
134 }
135 subTran->address_ = tran->address_ + (i * maxAccess);
136 subTran->type_ = tran->type();
137 subTransactions.push_back(subTran);
138
139 log_->debug("Created subTransaction %" PRIu32 ", parent=%" PRIu32 ", iter=%" PRIx32 ", size=%" PRIu32
140 ", address=%" PRIx64,
141 subTran->id_,
142 tran->id_,
143 subTran->iter_,
144 subTran->size_,
145 subTran->address_);
146 }
147
148 // Declare all subTransactions have been created
149 tran->doneSubTransactions();
150
151 // Completion can erase children from subTranMap_ during a downstream
152 // call. Keep stable ownership and iteration independent of that map.
153 for (const auto& subTran : subTransactions) {
154 getSlave()->doTransaction(subTran);
155 }
156 } else {
157 // Forward transaction
158 getSlave()->doTransaction(tran);
159 }
160}
161
162void rim::Hub::setup_python() {
163#ifndef NO_PYTHON
164 bp::class_<rim::HubWrap, rim::HubWrapPtr, bp::bases<rim::Master, rim::Slave>, boost::noncopyable>(
165 "Hub",
166 bp::init<uint64_t, uint32_t, uint32_t>())
167 .def("_blkMinAccess", &rim::Hub::doMinAccess)
168 .def("_blkMaxAccess", &rim::Hub::doMaxAccess)
169 .def("_getAddress", &rim::Hub::getAddress)
170 .def("_getOffset", &rim::Hub::getOffset)
171 .def("_doTransaction", &rim::Hub::doTransaction, &rim::HubWrap::defDoTransaction);
172
173 bp::implicitly_convertible<rim::HubPtr, rim::MasterPtr>();
174#endif
175}
176
177#ifndef NO_PYTHON
178
180rim::HubWrap::HubWrap(uint64_t offset, uint32_t min, uint32_t max) : rim::Hub(offset, min, max) {}
181
183void rim::HubWrap::doTransaction(rim::TransactionPtr transaction) {
184 // A C++ worker can still deliver a transaction while the interpreter
185 // shuts down; PyGILState_Ensure() aborts once finalization has started.
186 if (Py_IsInitialized()) {
188
189 if (boost::python::override pb = this->get_override("_doTransaction")) {
190 try {
191 pb(transaction);
192 return;
193 } catch (...) {
194 PyErr_Print();
195 }
196 }
197 }
198 rim::Hub::doTransaction(transaction);
199}
200
202void rim::HubWrap::defDoTransaction(rim::TransactionPtr transaction) {
203 rim::Hub::doTransaction(transaction);
204}
205
206#endif
static std::shared_ptr< rogue::Logging > create(const std::string &name, bool quiet=false)
Creates a logger instance.
Definition Logging.cpp:95
RAII helper that acquires the Python GIL for a scope.
Definition ScopedGil.h:35
Memory interface Hub device.
Definition Hub.h:72
Master endpoint for memory transactions.
Definition Master.h:50
Memory slave device.
Definition Slave.h:54
uint32_t max()
Returns configured maximum transaction size.
Definition Slave.cpp:139
uint32_t min()
Returns configured minimum transaction size.
Definition Slave.cpp:134
std::shared_ptr< rogue::interfaces::memory::Hub > HubPtr
Definition Hub.h:231
std::shared_ptr< rogue::interfaces::memory::Transaction > TransactionPtr
Shared pointer alias for Transaction.