unsigned int TreeData::calcSize()
{
unsigned int numNodes = 0;
for (NodeBase::const_dfs_pre_order_iterator nodeIt(m_root->begin_DFS());
nodeIt != m_root->end_DFS(); ++nodeIt, ++numNodes)
{}
return numNodes;
}
Values AsebaNetworkInterface::GetVariable(const QString& node, const QString& variable, const QDBusMessage &message)
{
// make sure the node exists
NodesNamesMap::const_iterator nodeIt(nodesNames.find(node));
if (nodeIt == nodesNames.end())
{
DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("node %0 does not exists").arg(node)));
return Values();
}
const unsigned nodeId(nodeIt.value());
unsigned pos(unsigned(-1));
unsigned length(unsigned(-1));
// check whether variable is user-defined
const UserDefinedVariablesMap::const_iterator userVarMapIt(userDefinedVariablesMap.find(node));
if (userVarMapIt != userDefinedVariablesMap.end())
{
const VariablesMap& userVarMap(userVarMapIt.value());
const VariablesMap::const_iterator userVarIt(userVarMap.find(variable.toStdWString()));
if (userVarIt != userVarMap.end())
{
pos = userVarIt->second.first;
length = userVarIt->second.second;
}
}
// if variable is not user-defined, check whether it is provided by this node
if (pos == unsigned(-1))
{
bool ok1, ok2;
pos = getVariablePos(nodeId, variable.toStdWString(), &ok1);
length = getVariableSize(nodeId, variable.toStdWString(), &ok2);
if (!(ok1 && ok2))
{
DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("variable %0 does not exists in node %1").arg(variable).arg(node)));
return Values();
}
}
// send request to aseba network
{
GetVariables msg(nodeId, pos, length);
hub->sendMessage(msg);
}
// build bookkeeping for async reply
RequestData *request = new RequestData;
request->nodeId = nodeId;
request->pos = pos;
message.setDelayedReply(true);
request->reply = message.createReply();
pendingReads.push_back(request);
return Values();
}
bool AsebaNetworkInterface::IsConnected(const QString& node, const QDBusMessage &message) const
{
NodesNamesMap::const_iterator nodeIt(nodesNames.find(node));
if (nodeIt == nodesNames.end())
{
DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("node %0 does not exists").arg(node)));
return 0;
}
return nodes.find(nodeIt.value())->second.connected;
}
std::vector<lemon::ListDigraph::Node> SchedulerCPU::GetSourceNodes(const lemon::ListDigraph& graph) {
std::vector<lemon::ListDigraph::Node> sources;
for (lemon::ListDigraph::NodeIt nodeIt(graph); nodeIt != lemon::INVALID; ++nodeIt) {
size_t numDependencies = countInArcs(graph, nodeIt);
if (numDependencies == 0) {
sources.push_back(nodeIt);
}
}
return sources;
}
MStatus lrutils::getMetaRootByName(MObject & obj, MString name) {
MStatus status = MS::kFailure;
for( MItDependencyNodes nodeIt(MFn::kPluginDependNode);
!nodeIt.isDone(); nodeIt.next() ) {
MFnDependencyNode nodeFn( nodeIt.item() );
if(nodeFn.typeId() == MetaDataManagerNode::id) {
//Get the plug for the list of metaRoots
MPlug metaRootsPlug = nodeFn.findPlug(MString("metaRoots"),true,&status);
MyCheckStatusReturn(status,"findPlug failed");
//MGlobal::displayInfo( metaRootsPlug.name() );
//follow its connection to all the plugs on connected metaRoots
MPlugArray rootPlugs;
metaRootsPlug.connectedTo(rootPlugs,false,true,&status);
MyCheckStatusReturn(status,"MPlug.connectedTo failed");
unsigned int numRootPlugs = rootPlugs.length();
for(unsigned int i = 0; i < numRootPlugs; i++) {
MObject rootNodeObj = rootPlugs[i].node(&status);
MyCheckStatusReturn(status,"MPlug.node() failed");
MFnDependencyNode rootNodeFn( rootNodeObj );
//get the name of the metaRoot node and compare it to the search string
MString rootName = rootNodeFn.name();
rootName = rootName.substring(4,rootName.numChars());
if( rootName == name ) {
obj = rootNodeObj;
status = MS::kSuccess;
break;
}
}
}
}
if(status == MS::kFailure) {
MGlobal::displayInfo("MetaDataManager node does not exist.\n");
}
return status;
}
void AsebaNetworkInterface::SetVariable(const QString& node, const QString& variable, const Values& data, const QDBusMessage &message) const
{
// make sure the node exists
NodesNamesMap::const_iterator nodeIt(nodesNames.find(node));
if (nodeIt == nodesNames.end())
{
DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("node %0 does not exists").arg(node)));
return;
}
const unsigned nodeId(nodeIt.value());
unsigned pos(unsigned(-1));
// check whether variable is user-defined
const UserDefinedVariablesMap::const_iterator userVarMapIt(userDefinedVariablesMap.find(node));
if (userVarMapIt != userDefinedVariablesMap.end())
{
const VariablesMap& userVarMap(userVarMapIt.value());
const VariablesMap::const_iterator userVarIt(userVarMap.find(variable.toStdWString()));
if (userVarIt != userVarMap.end())
{
pos = userVarIt->second.first;
}
}
// if variable is not user-defined, check whether it is provided by this node
if (pos == unsigned(-1))
{
bool ok;
pos = getVariablePos(nodeId, variable.toStdWString(), &ok);
if (!ok)
{
DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("variable %0 does not exists in node %1").arg(variable).arg(node)));
return;
}
}
SetVariables msg(nodeId, pos, toAsebaVector(data));
hub->sendMessage(msg);
}
void NodesManager::processMessage(const Message* message)
{
// check whether the node is known
NodesMap::iterator nodeIt(nodes.find(message->source));
if (nodeIt == nodes.end())
{
// node is not known, so ignore excepted if the message type
// is node present and it is not a known mismatch protocol,
// in that case, request description...
if ((message->type == ASEBA_MESSAGE_NODE_PRESENT) &&
mismatchingNodes.find(message->source) == mismatchingNodes.end())
{
GetNodeDescription getNodeDescription(message->source);
sendMessage(getNodeDescription);
}
// or if message type is description, in that case, proceed further
if (message->type != ASEBA_MESSAGE_DESCRIPTION)
return;
}
else
{
// node is known, check if connected...
if (!nodeIt->second.connected)
{
// if not, build complete, set as connected and notify client
nodeIt->second.connected = true;
if (nodeIt->second.isComplete())
{
// only notify connections of completed known nodes
nodeConnected(nodeIt->first);
}
}
// update last seen time
nodeIt->second.lastSeen = UnifiedTime();
}
// if we have a disconnection message
{
// FIXME: handle disconnected state
const Disconnected *disconnected = dynamic_cast<const Disconnected *>(message);
if (disconnected)
{
NodesMap::iterator nodeIt = nodes.find(disconnected->source);
assert (nodeIt != nodes.end());
nodes.erase(nodeIt);
}
}
// if we have an initial description
{
const Description *description = dynamic_cast<const Description *>(message);
if (description)
{
NodesMap::iterator nodeIt = nodes.find(description->source);
// We can receive a description twice, for instance if there is another IDE connected
if (nodeIt != nodes.end() || (mismatchingNodes.find(description->source) != mismatchingNodes.end()))
return;
// Call a user function when a node protocol version mismatches
if ((description->protocolVersion < ASEBA_MIN_TARGET_PROTOCOL_VERSION) ||
(description->protocolVersion > ASEBA_PROTOCOL_VERSION))
{
nodeProtocolVersionMismatch(description->source, description->name, description->protocolVersion);
mismatchingNodes.insert(description->source);
return;
}
// create node and copy description into it
nodes[description->source] = Node(*description);
checkIfNodeDescriptionComplete(description->source, nodes[description->source]);
}
}
// if we have a named variable description
{
const NamedVariableDescription *description = dynamic_cast<const NamedVariableDescription *>(message);
if (description)
{
NodesMap::iterator nodeIt = nodes.find(description->source);
assert (nodeIt != nodes.end());
// copy description into array if array is empty
if (nodeIt->second.namedVariablesReceptionCounter < nodeIt->second.namedVariables.size())
{
nodeIt->second.namedVariables[nodeIt->second.namedVariablesReceptionCounter++] = *description;
checkIfNodeDescriptionComplete(nodeIt->first, nodeIt->second);
}
}
}
// if we have a local event description
{
const LocalEventDescription *description = dynamic_cast<const LocalEventDescription *>(message);
if (description)
{
NodesMap::iterator nodeIt = nodes.find(description->source);
assert (nodeIt != nodes.end());
// copy description into array if array is empty
if (nodeIt->second.localEventsReceptionCounter < nodeIt->second.localEvents.size())
{
nodeIt->second.localEvents[nodeIt->second.localEventsReceptionCounter++] = *description;
checkIfNodeDescriptionComplete(nodeIt->first, nodeIt->second);
}
}
}
// if we have a native function description
{
const NativeFunctionDescription *description = dynamic_cast<const NativeFunctionDescription *>(message);
if (description)
{
NodesMap::iterator nodeIt = nodes.find(description->source);
assert (nodeIt != nodes.end());
// copy description into array
if (nodeIt->second.nativeFunctionReceptionCounter < nodeIt->second.nativeFunctions.size())
{
nodeIt->second.nativeFunctions[nodeIt->second.nativeFunctionReceptionCounter++] = *description;
checkIfNodeDescriptionComplete(nodeIt->first, nodeIt->second);
}
}
}
}
void SchedulerCPU::LaunchTasks(const FrameContextEx& context, std::function<jobs::Future<std::any>(const FrameContextEx&, const Pipeline&, lemon::ListDigraph::Node, std::any)> onNode) {
struct DependencyCounter {
public:
explicit DependencyCounter(size_t total = 0) {
this->total = total;
}
void Reset() {
*counter = 0;
}
bool operator++() {
return (counter->fetch_add(1) + 1) == total;
}
private:
std::shared_ptr<std::atomic_size_t> counter = std::make_shared<std::atomic_size_t>(0);
std::size_t total = 0;
};
lemon::ListDigraph::NodeMap<DependencyCounter> depCounter(m_pipeline->GetTaskGraph());
for (lemon::ListDigraph::NodeIt nodeIt(m_pipeline->GetTaskGraph()); nodeIt != lemon::INVALID; ++nodeIt) {
depCounter[nodeIt] = DependencyCounter{ (size_t)lemon::countInArcs(m_pipeline->GetTaskGraph(), nodeIt) };
}
auto stopFlag = std::make_shared<std::atomic_bool>(false);
auto Traverse = [this, &context, stopFlag, &onNode, &depCounter](lemon::ListDigraph::Node node, std::any passThrough, auto self) -> jobs::Future<void> {
if (stopFlag->load()) {
co_return;
}
try {
std::any passToNext = co_await onNode(context, *m_pipeline, node, passThrough);
std::vector<jobs::Future<void>> childJobs;
for (lemon::ListDigraph::OutArcIt outArc(m_pipeline->GetTaskGraph(), node); outArc != lemon::INVALID; ++outArc) {
auto nextNode = m_pipeline->GetTaskGraph().target(outArc);
if (++depCounter[nextNode]) {
childJobs.push_back(m_scheduler->Enqueue(self, nextNode, passToNext, self));
}
}
for (auto& childFuture : childJobs) {
co_await childFuture;
}
}
catch (...) {
stopFlag->store(true);
throw;
}
};
auto sourceNodes = GetSourceNodes(m_pipeline->GetTaskGraph());
std::vector<jobs::Future<void>> childJobs;
for (auto sourceNode : sourceNodes) {
childJobs.push_back(m_scheduler->Enqueue(Traverse, sourceNode, std::any{}, Traverse));
}
std::vector<std::exception_ptr> exceptions;
for (auto& job : childJobs) {
try {
job.get();
}
catch (...) {
exceptions.push_back(std::current_exception());
}
}
if (!exceptions.empty()) {
// Rest of the exceptions is ignored.
// TODO: throw some aggregate exception?
std::rethrow_exception(exceptions[0]);
}
}