Merge branch 'dev' into im2col

include/aidge/graph/GraphView.hpp

@@ -400,10 +400,17 @@ public:
         addChild(toOtherNode, mNodeRegistry.at(fromOutNodeName), fromTensor, toTensor);
     }
 
-    inline void updateNodeName(const std::string& oldName, const std::string& newName){
-        AIDGE_ASSERT(mNodeRegistry.find(oldName) != mNodeRegistry.end(), "No node named {} in graph {}, the graph may be corrupted !", oldName, name());
-        mNodeRegistry[newName] = mNodeRegistry[oldName];
-        mNodeRegistry.erase(oldName);
+    inline void updateNodeName(NodePtr nodeToRename, const std::string& newName){
+        const std::string& oldName = nodeToRename->name();
+        AIDGE_ASSERT(mNodeRegistry.find(newName) != mNodeRegistry.end(), "Name {} is already used in graph {}.", newName, name());
+
+        if (nodeToRename->name() != ""){ // Case node already had a name
+            AIDGE_ASSERT(mNodeRegistry.find(oldName) != mNodeRegistry.end(), "No node named {} in graph {}, the graph may be corrupted !", oldName, name());
+            mNodeRegistry[newName] = mNodeRegistry[oldName];
+            mNodeRegistry.erase(oldName);
+        }else{ // Case node did not had a name
+            mNodeRegistry[newName] = nodeToRename;
+        }
     }
 
     /**

include/aidge/operator/MetaOperator.hpp

@@ -108,6 +108,7 @@ public:
     Elts_t getNbProducedData(IOIndex_t outputIdx) const override;
 
     void updateConsummerProducer() override;
+    void resetConsummerProducer() override;
     void forward() override;
     void backward() override {
         AIDGE_THROW_OR_ABORT(std::runtime_error, "backward() not implemented yet for a MetaOperator");

src/graph/Node.cpp

@@ -64,7 +64,7 @@ Aidge::Connector Aidge::Node::operator()(const std::vector<Connector>& ctors) {
 ///////////////////////////////////////////////////////
 
 void Aidge::Node::setName(const std::string& name) {
-    for (auto graphView : views()) graphView->updateNodeName(mName, name);
+    for (auto graphView : views()) graphView->updateNodeName(shared_from_this(), name);
     mName = name;
 }
 

src/operator/MetaOperator.cpp

@@ -134,6 +134,20 @@ Aidge::Elts_t Aidge::MetaOperator_Op::getNbProducedData(IOIndex_t outputIdx) con
     }
 }
 
+void Aidge::MetaOperator_Op::resetConsummerProducer() {
+    if (mImpl) {
+        mImpl->resetConsummerProducer();
+    }
+    else {
+        if (!mScheduler) {
+            // Lazy initialization
+            mScheduler = std::make_shared<SequentialScheduler>(mGraph, mUpperNode.lock());
+        }
+
+        mScheduler->resetScheduling();
+    }
+}
+
 void Aidge::MetaOperator_Op::updateConsummerProducer() {
     if (mImpl) {
         mImpl->updateConsummerProducer();

src/operator/Slice.cpp

@@ -147,13 +147,13 @@ bool Aidge::Slice_Op::forwardDims(bool allowDataDependency) {
                             static_cast<DimSize_t>(this->ends()[i] + static_cast<DimSize_t>(getInput(0)->dims()[axis]));
             const std::int64_t step = this->steps()[i];
 
-            AIDGE_ASSERT(step != 0, "Slice_Op: Step must be a non-zero value!");
+            AIDGE_ASSERT(step != 0, "Slice_Op: Step ({}) must have a non-zero value on axis {}!", this->steps(), axis);
             if(step * (static_cast<int64_t>(end) - static_cast<int64_t>(start)) < 0) {
                 if(step < 0) {
-                    AIDGE_THROW_OR_ABORT(std::runtime_error, "{}: Step is negative we must have End < Start", type());
+                    AIDGE_THROW_OR_ABORT(std::runtime_error, "{}: Step ({}) is negative, we must have End ({}) < Start ({}) on axis {}", type(), step, end, start, axis);
                 }
                 else {
-                    AIDGE_THROW_OR_ABORT(std::runtime_error, "{}: Step is positive we must have Start < End", type());
+                    AIDGE_THROW_OR_ABORT(std::runtime_error, "{}: Step ({}) is positive, we must have Start ({}) < End ({}) on axis {}", type(), step, start, end, axis);
                 }
             }
 
@@ -161,7 +161,8 @@ bool Aidge::Slice_Op::forwardDims(bool allowDataDependency) {
             // Check if slice length is valid
             if (sliceLength > getInput(0)->dims()[axis])
             {
-                AIDGE_THROW_OR_ABORT(std::runtime_error, "Slice_Op: ROI of Slice operator out of bounds");
+                AIDGE_THROW_OR_ABORT(std::runtime_error, "Slice_Op: ROI ({}) of Slice operator out of bounds ({}) on axis {}, with (Start, End, Step) = ({}, {}, {})",
+                    sliceLength, getInput(0)->dims()[axis], axis, start, end, step);
             }
             outDims[axis] = sliceLength;
         }