diff --git a/include/aidge/operator/AvgPoolingImpl_forward_kernels.hpp b/include/aidge/operator/AvgPoolingImpl_forward_kernels.hpp
index 7ff3243d3b9e6393e0f3aa532599ecab715d77e2..7ead482c61866d263c19dcbf777ca2a5587a7cd7 100644
--- a/include/aidge/operator/AvgPoolingImpl_forward_kernels.hpp
+++ b/include/aidge/operator/AvgPoolingImpl_forward_kernels.hpp
@@ -63,11 +63,11 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const AvgPooling_Op<2>::Parameters &par
             for (std::size_t ox = 0; ox < oxSize; ++ox) {
                 const signedsize difx = static_cast<signedsize>(std::get<2>(params)[0] - ox * std::get<0>(params)[0]);
                 const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
-                const std::size_t sxMax = (dims[2] + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<1>(params)[0] ? std::get<1>(params)[0] : dims[2] + difx);
+                const std::size_t sxMax = (static_cast<signedsize>(dims[2]) + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<1>(params)[0] ? std::get<1>(params)[0] : dims[2] + difx);
                 for (std::size_t oy = 0; oy < oySize; ++oy) {
                     const signedsize dify = static_cast<signedsize>(std::get<2>(params)[1] - oy * std::get<0>(params)[1]);
                     const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
-                    const std::size_t syMax = (dims[3] + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<1>(params)[1] ? std::get<1>(params)[1] : dims[3] + dify);
+                    const std::size_t syMax = (static_cast<signedsize>(dims[3]) + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<1>(params)[1] ? std::get<1>(params)[1] : dims[3] + dify);
                     const std::size_t oIndexFull = oIndex + ox*oySize + oy;
                     const std::size_t ix = ox * std::get<0>(params)[0];
                     const std::size_t iy = oy * std::get<0>(params)[1];
diff --git a/include/aidge/operator/ConvDepthWiseImpl_forward_kernels.hpp b/include/aidge/operator/ConvDepthWiseImpl_forward_kernels.hpp
index 6a7ec3fe73edc68a4bd9957d8abc207811369df4..da9c8dafb4a5219f17d72dbae90aeb9e08d3585f 100644
--- a/include/aidge/operator/ConvDepthWiseImpl_forward_kernels.hpp
+++ b/include/aidge/operator/ConvDepthWiseImpl_forward_kernels.hpp
@@ -69,11 +69,11 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const ConvDepthWise_Op<2>::Parameter
             for (std::size_t ox = 0; ox < oxSize; ++ox) {
                 const signedsize difx = static_cast<signedsize>(std::get<4>(params)[0] - ox * std::get<0>(params)[0]);
                 const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
-                const std::size_t sxMax = (dims[2] + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<3>(params)[0] ? std::get<3>(params)[0] : dims[2] + difx);
+                const std::size_t sxMax = (static_cast<signedsize>(dims[2]) + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<3>(params)[0] ? std::get<3>(params)[0] : dims[2] + difx);
                 for (std::size_t oy = 0; oy < oySize; ++oy) {
                     const signedsize dify = static_cast<signedsize>(std::get<4>(params)[1] - oy * std::get<0>(params)[1]);
                     const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
-                    const std::size_t syMax = (dims[3] + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<3>(params)[1] ? std::get<3>(params)[1] : dims[3] + dify);
+                    const std::size_t syMax = (static_cast<signedsize>(dims[3]) + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<3>(params)[1] ? std::get<3>(params)[1] : dims[3] + dify);
                     const std::size_t oIndexFull = oIndex + ox*oySize + oy;
                     const signedsize ix = static_cast<signedsize>(ox * std::get<0>(params)[0]) - std::get<4>(params)[0];
                     const signedsize iy = static_cast<signedsize>(oy * std::get<0>(params)[1]) - std::get<4>(params)[1];
diff --git a/include/aidge/operator/ConvImpl_forward_kernels.hpp b/include/aidge/operator/ConvImpl_forward_kernels.hpp
index 459b5c81c1d8a46fedb61590084bfea59e6372bf..93cf523baf904ad98eb81c62a94b43bac02c072e 100644
--- a/include/aidge/operator/ConvImpl_forward_kernels.hpp
+++ b/include/aidge/operator/ConvImpl_forward_kernels.hpp
@@ -112,11 +112,11 @@ void ConvImpl2D_cpu_forward_kernel(const Conv_Op<2>::Parameters &params, const s
                 for (std::size_t ox = 0; ox < oxSize; ++ox) {
                     const signedsize difx = static_cast<signedsize>(std::get<5>(params)[0] - ox * std::get<0>(params)[0]);
                     const std::size_t sxMin = static_cast<std::size_t>(std::max(difx, signedsize(0)));
-                    const std::size_t sxMax = (dims[2] + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<4>(params)[0] ? std::get<4>(params)[0] : dims[2] + difx);
+                    const std::size_t sxMax = (static_cast<signedsize>(dims[2]) + difx) < 0 ? 0 : ((dims[2] + difx) > std::get<4>(params)[0] ? std::get<4>(params)[0] : dims[2] + difx);
                     for (std::size_t oy = 0; oy < oySize; ++oy) {
                         const signedsize dify = static_cast<signedsize>(std::get<5>(params)[1] - oy * std::get<0>(params)[1]);
                         const std::size_t syMin = static_cast<std::size_t>(std::max(dify, signedsize(0)));
-                        const std::size_t syMax = (dims[3] + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<4>(params)[1] ? std::get<4>(params)[1] : dims[3] + dify);
+                        const std::size_t syMax = (static_cast<signedsize>(dims[3]) + dify) < 0 ? 0 : ((dims[3] + dify) > std::get<4>(params)[1] ? std::get<4>(params)[1] : dims[3] + dify);
                         const std::size_t oIndexFull = oIndex + ox*oySize + oy;
                         const signedsize ix = static_cast<signedsize>(ox * std::get<0>(params)[0]) - std::get<5>(params)[0];
                         const signedsize iy = static_cast<signedsize>(oy * std::get<0>(params)[1]) - std::get<5>(params)[1];
diff --git a/src/operator/AvgPoolingImpl.cpp b/src/operator/AvgPoolingImpl.cpp
index 2e1e901d35f2ac8620f1c4be53413ce58e9260f9..eebaa5ddebd7e2f392187cbbd0fb6afb1f3a1dbb 100644
--- a/src/operator/AvgPoolingImpl.cpp
+++ b/src/operator/AvgPoolingImpl.cpp
@@ -39,6 +39,7 @@ Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getRequiredMemory(const Aidge::IOIn
                                                            const std::vector<Aidge::DimSize_t> & /*inputsSize*/) const {
     // Requires the whole tensors, regardless of available data on inputs
     assert(outputIdx == 0 && "operator has only one output");
+    (void) outputIdx;
 
     const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
     return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
diff --git a/src/operator/ConvDepthWiseImpl.cpp b/src/operator/ConvDepthWiseImpl.cpp
index ce5063dde6e208ca6ae9ba49cb88aa2b49336c27..75a35cff1a56c2ee619e00e70f4c8e5d93356d68 100644
--- a/src/operator/ConvDepthWiseImpl.cpp
+++ b/src/operator/ConvDepthWiseImpl.cpp
@@ -36,10 +36,11 @@ Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(IOIndex_t
     return 0;
 }
 
-Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t /*outputIdx*/,
+Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
                                                            const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const {
     // Requires the whole tensors, regardless of available data on inputs
     assert(outputIdx == 0 && "operator has only one output");
+    (void) outputIdx;
 
     const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
     return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
diff --git a/src/operator/ConvImpl.cpp b/src/operator/ConvImpl.cpp
index a1b3e2ca3ed3b509360a035bafd66bf90e5c9565..e75fab1073f9da2bcd95ad7d0f6485164dc6be31 100644
--- a/src/operator/ConvImpl.cpp
+++ b/src/operator/ConvImpl.cpp
@@ -36,10 +36,11 @@ Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputI
     return 0;
 }
 
-Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t /*outputIdx*/,
+Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
                                                          const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const {
     // Requires the whole tensors, regardless of available data on inputs
     assert(outputIdx == 0 && "operator has only one output");
+    (void) outputIdx;
 
     const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
     return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
diff --git a/src/operator/FCImpl.cpp b/src/operator/FCImpl.cpp
index ca4eebcfcfaba457c415aca5b749059af894a1c2..970ce690e08a06bf89d19f1c09ab429d3053293b 100644
--- a/src/operator/FCImpl.cpp
+++ b/src/operator/FCImpl.cpp
@@ -44,10 +44,11 @@ Aidge::NbElts_t
 }
 
 Aidge::NbElts_t Aidge::FCImpl_cpu::getRequiredMemory(
-    const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const
+    const IOIndex_t outputIdx, const std::vector<DimSize_t> &/*inputsSize*/) const
 {
     // Requires the whole tensors, regardless of available data on inputs
     assert(outputIdx == 0 && "operator has only one output");
+    (void) outputIdx;
 
     const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
     return std::accumulate(
diff --git a/src/operator/ProducerImpl.cpp b/src/operator/ProducerImpl.cpp
index b7f1538dd653c798ba1036e0f6552222aea78e19..6c1de523a01d8bd1cd118d64b5c5cefd0563789d 100644
--- a/src/operator/ProducerImpl.cpp
+++ b/src/operator/ProducerImpl.cpp
@@ -42,10 +42,11 @@ std::size_t Aidge::ProducerImpl_cpu::getNbRequiredProtected(
 
 
 std::size_t Aidge::ProducerImpl_cpu::getRequiredMemory(
-    const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const
+    const IOIndex_t outputIdx, const std::vector<DimSize_t> &/*inputsSize*/) const
 {
     // Requires the whole tensors, regardless of available data on inputs
     assert(outputIdx == 0 && "operator has only one output");
+    (void) outputIdx;
 
     const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
     return std::accumulate(