Added new conversion facilities to Tensor

include/aidge/data/Tensor.hpp

@@ -629,7 +629,22 @@ class Tensor : public Data,
         return flatIdx + coordIdx[i];
     }
 
+    /**
+     * Copy-cast data from a Tensor.
+     * @param src Source tensor to copy-cast from.
+     * @param convertedSrc shared_ptr to an indermediate Tensor that will 
+     * contain the converted data if a conversion should occur. Any data already
+     * present will be overwritten. No new memory allocation will occur if 
+     * convertedSrc has already been allocated with the right type/size/device.
+    */
     void copyCastFrom(const Tensor& src, std::shared_ptr<Tensor>& convertedSrc);
+
+    /**
+     * Copy-cast data from a Tensor.
+     * In case of a conversion, an intermediate buffer will be allocated and
+     * deallocated each time.
+     * @param src Source tensor to copy-cast from.
+    */
     void copyCastFrom(const Tensor& src) {
         // Internal buffers will be allocated and deallocated at each call
         // (if they are needed)
@@ -637,6 +652,54 @@ class Tensor : public Data,
         copyCastFrom(src, convertedSrc);
     }
 
+    /**
+     * Return a reference to a Tensor casted to the desired data type:
+     * - itself, if already at the right data type;
+     * - the provided Tensor, overwritten with the copy-casted data.
+     * The backend stays the same.
+     * @param fallback A shared_ptr to Tensor ready to be overwritten if necessary.
+     * The shared_ptr does not need to be initialized. No new memory allocation
+     * will occur if fallback has already been allocated with the right 
+     * type/size/device.
+     * @param dt The desired data type.
+     * @return Reference to either itself or to fallback.
+    */
+    Tensor& refCast(std::shared_ptr<Tensor>& fallback, const Aidge::DataType& dt);
+    const Tensor& refCast(std::shared_ptr<Tensor>& fallback, const Aidge::DataType& dt) const;
+
+    /**
+     * Return a reference to a Tensor on the desired backend/device:
+     * - itself, if already on the right device;
+     * - the provided Tensor, overwritten with the copied data.
+     * The data type stays the same.
+     * @param fallback A shared_ptr to Tensor ready to be overwritten if necessary.
+     * The shared_ptr does not need to be initialized. No new memory allocation
+     * will occur if fallback has already been allocated with the right 
+     * type/size/device.
+     * @param backend The desired backend.
+     * @param device The desired device.
+     * @return Reference to either itself or to fallback.
+    */
+    Tensor& ref(std::shared_ptr<Tensor>& fallback, const std::string &backend, int device = 0);
+    const Tensor& ref(std::shared_ptr<Tensor>& fallback, const std::string &backend, int device = 0) const;
+
+    /**
+     * Return a reference to a Tensor with same characteristics
+     * (data type, backend/device) as target Tensor:
+     * - itself, if already with the right characteristics;
+     * - the provided Tensor, overwritten with the copy-casted data.
+     * @param fallback A shared_ptr to Tensor ready to be overwritten if necessary.
+     * The shared_ptr does not need to be initialized. No new memory allocation
+     * will occur if fallback has already been allocated with the right 
+     * type/size/device.
+     * @param target Tensor with the desired target characteristics.
+     * @return Reference to either itself or to fallback.
+    */
+    Tensor& refCast(std::shared_ptr<Tensor>& fallback, const Tensor& target) {
+        const auto& device = target.getImpl()->device();
+        return refCast(fallback, target.dataType()).ref(fallback, device.first, device.second);
+    }
+
 private:
     ///\bug not protected against overflow
     std::size_t computeSize() {

include/aidge/operator/Conv.hpp

@@ -174,10 +174,6 @@ std::vector<std::pair<std::size_t, std::vector<DimSize_t>>> computeReceptiveFiel
     void setBackend(const std::string &name, int device = 0) override {
         mImpl = Registrar<Conv_Op<DIM>>::create(name)(*this);
         mOutputs[0]->setBackend(name, device);
-
-        // FIXME: temporary workaround
-        getInput(1)->setBackend(name, device);
-        getInput(2)->setBackend(name, device);
     }
 
     static const std::vector<std::string> getInputsName(){

include/aidge/utils/Registrar.hpp

@@ -51,6 +51,9 @@ public:
 
 template <class C>
 struct Registrar {
+    typedef typename C::registrar_key registrar_key;
+    typedef typename C::registrar_type registrar_type;
+
     Registrar(const typename C::registrar_key& key, typename C::registrar_type func) {
         //printf("REGISTRAR: %s\n", key.c_str());
         bool newInsert;

src/data/Tensor.cpp

@@ -14,22 +14,59 @@
 #include "aidge/utils/ErrorHandling.hpp"
 
 void Aidge::Tensor::copyCastFrom(const Tensor& src, std::shared_ptr<Tensor>& convertedSrcPtr) {
-    // convertedSrcPtr stores data to the desired (dst) type
-    if (src.dataType() != dataType()) {
-        // Different type: create a new tensor on same src device
-        if (!convertedSrcPtr) {
-            convertedSrcPtr = std::make_shared<Tensor>(dataType());
+    if (src == *this) {
+        return;
+    }
+
+    const Tensor& convertedSrc = src.refCast(convertedSrcPtr, dataType());
+    getImpl()->copyFrom(*(convertedSrc.getImpl()), convertedSrc.size());
+}
+
+Aidge::Tensor& Aidge::Tensor::refCast(std::shared_ptr<Tensor>& fallback, const Aidge::DataType& dt) {
+    // Scott Meyers' solution to avoid code duplication
+    return const_cast<Tensor&>(static_cast<const Tensor&>(*this).refCast(fallback, dt));
+}
+
+const Aidge::Tensor& Aidge::Tensor::refCast(std::shared_ptr<Tensor>& fallback, const Aidge::DataType& dt) const {
+    if (dt == dataType()) {
+        return *this;
+    }
+    else {
+        if (!fallback) {
+            fallback = std::make_shared<Tensor>(dt);
+        }
+        else {
+            fallback->setDataType(dt);
         }
 
-        convertedSrcPtr->setDataType(dataType());
-        const auto device = src.getImpl()->device();
-        convertedSrcPtr->setBackend(device.first, device.second);
-        convertedSrcPtr->resize(src.dims());
+        const auto device = getImpl()->device();
+        fallback->setBackend(device.first, device.second);
+        fallback->resize(dims());
+        fallback->getImpl()->copyCast(getImpl()->rawPtr(), size(), dt);
+        return *fallback;
+    }
+}
+
+Aidge::Tensor& Aidge::Tensor::ref(std::shared_ptr<Tensor>& fallback, const std::string &backend, int device) {
+    // Scott Meyers' solution to avoid code duplication
+    return const_cast<Tensor&>(static_cast<const Tensor&>(*this).ref(fallback, backend, device));
+}
 
-        // Copy convert src to convertedSrcPtr
-        convertedSrcPtr->getImpl()->copyCast(src.getImpl()->rawPtr(), src.size(), src.dataType());
+const Aidge::Tensor& Aidge::Tensor::ref(std::shared_ptr<Tensor>& fallback, const std::string &backend, int device) const {
+    if (std::make_pair(backend, device) == getImpl()->device()) {
+        return *this;
     }
+    else {
+        if (!fallback) {
+            fallback = std::make_shared<Tensor>(dataType());
+        }
+        else {
+            fallback->setDataType(dataType());
+        }
 
-    const Tensor& convertedSrc = (src.dataType() != dataType()) ? *convertedSrcPtr : src;
-    getImpl()->copyFrom(*(convertedSrc.getImpl()), convertedSrc.size());
+        fallback->setBackend(backend, device);
+        fallback->resize(dims());
+        fallback->getImpl()->copyFrom(*getImpl(), size());
+        return *fallback;
+    }
 }