diff --git a/include/backend/OperatorImpl.hpp b/include/backend/OperatorImpl.hpp
index a2c97c6073959ff4134bf91e634611291b1eeced..4cf6eef6017a59e383d9f00d44ea321820e4c06d 100644
--- a/include/backend/OperatorImpl.hpp
+++ b/include/backend/OperatorImpl.hpp
@@ -35,7 +35,7 @@ public:
virtual NbElts_t getNbRequiredProtected(IOIndex_t inputIdx) const = 0;
// Memory required at an output for a given input size.
- virtual NbElts_t getRequiredMemory(IOIndex_t outputIdx, const std::vector<DimSize_t> &inputsSize) const = 0;
+ virtual NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t> &inputsSize) const = 0;
/**
* @brief Total amount of consumed data from a specific input.
diff --git a/include/operator/Add.hpp b/include/operator/Add.hpp
index 42720af858a6deef4c9ea402f13d303647ddbf86..fc2dc8a47a0a0bb834e3374eccfeeced631b436d 100644
--- a/include/operator/Add.hpp
+++ b/include/operator/Add.hpp
@@ -57,7 +57,7 @@ public:
// return *in;
// }
- constexpr void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ constexpr void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
@@ -93,13 +93,13 @@ public:
assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
return *(mInputs[inputIdx].get());
}
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
return mInputs[inputIdx];
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "Add Operators has only 1 outputs");
return mOutput;
}
@@ -108,7 +108,7 @@ public:
assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
return std::static_pointer_cast<Data>(mInputs[inputIdx]);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/AvgPooling.hpp b/include/operator/AvgPooling.hpp
index c3321dc245bba383a16e954999091903bca686cb..35a401fef4d408aa0f30c5e5af23a5171f8c2193 100644
--- a/include/operator/AvgPooling.hpp
+++ b/include/operator/AvgPooling.hpp
@@ -63,7 +63,7 @@ public:
setDatatype(DataType::Float32);
}
- constexpr void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx < 1 && "operators supports only 3 inputs");
assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
@@ -91,28 +91,28 @@ public:
bool outputDimsForwarded() const override final { return !(mOutput->empty()); }
- inline Tensor& input(const IOIndex_t inputIdx) const override final {
+ inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(inputIdx == 0 && "operators supports only 1 inputs");
return *(mInput.get());
}
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
+ inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(inputIdx == 0 && "AvgPooling Operators supports only 1 inputs");
return mInput;
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "AvgPooling Operators has only 1 outputs");
return mOutput;
}
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
+ std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(inputIdx == 0 && "operators supports only 1 inputs");
return std::static_pointer_cast<Data>(mInput);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/BatchNorm.hpp b/include/operator/BatchNorm.hpp
index d46f971f1b9afcfe1356d18aa61fa6dd0ea4dfbe..9499cff111d2497f72309329c7d050c3acc9419b 100644
--- a/include/operator/BatchNorm.hpp
+++ b/include/operator/BatchNorm.hpp
@@ -65,7 +65,7 @@ public:
// return *in;
// }
- constexpr void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx < 5 && "operators supports only 5 inputs");
assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
@@ -90,14 +90,14 @@ public:
assert(inputIdx < 5 && "operators supports only 5 inputs");
return *(mInputs[inputIdx].get()); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 5 && "BatchNorm Operators supports only 5 inputs");
return mInputs[inputIdx];
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "BatchNorm Operator has only 1 output");
return mOutput;
}
@@ -107,7 +107,7 @@ public:
assert(inputIdx < 5 && "operators supports only 5 inputs");
return std::static_pointer_cast<Data>(mInputs[inputIdx]);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/Conv.hpp b/include/operator/Conv.hpp
index 2e9f67df5ae21e39f878c3aa91f95c3888805901..1de05af0b60653b06394b6e39dcf92570dee5380 100644
--- a/include/operator/Conv.hpp
+++ b/include/operator/Conv.hpp
@@ -79,7 +79,7 @@ public:
// }
- constexpr void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx < 3 && "operators supports only 3 inputs");
assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
@@ -114,14 +114,14 @@ public:
inline Tensor& input(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 3 && "operators supports only 3 inputs");
return *(mInputs[inputIdx].get()); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 3 && "Conv Operators supports only 3 inputs");
return mInputs[inputIdx];
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "Conv Operator has only 1 output");
return mOutput;
}
@@ -131,7 +131,7 @@ public:
assert(inputIdx < 3 && "operators supports only 3 inputs");
return std::static_pointer_cast<Data>(mInputs[inputIdx]);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/ConvDepthWise.hpp b/include/operator/ConvDepthWise.hpp
index fa268a32e9ab8af773da85268b5e76364788c6c2..c9a0e6b0171be79371e74f6a8f6ebebb2b901364 100644
--- a/include/operator/ConvDepthWise.hpp
+++ b/include/operator/ConvDepthWise.hpp
@@ -71,7 +71,7 @@ class ConvDepthWise_Op : public Operator,
setDatatype(DataType::Float32);
}
- constexpr void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx < 3 && "operators supports only 3 inputs");
assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
@@ -114,14 +114,14 @@ class ConvDepthWise_Op : public Operator,
assert(inputIdx < 3 && "operators supports only 3 inputs");
return *(mInputs[inputIdx].get());
}
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 3 && "ConvDepthWise Operators supports only 3 inputs");
return mInputs[inputIdx];
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "ConvDepthWise Operator has only 1 output");
return mOutput;
}
@@ -131,7 +131,7 @@ class ConvDepthWise_Op : public Operator,
assert(inputIdx < 3 && "operators supports only 3 inputs");
return std::static_pointer_cast<Data>(mInputs[inputIdx]);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/FC.hpp b/include/operator/FC.hpp
index 99895790995048329f8996f99a3f0eb45263069a..240210f40392d7ac8aaf5bc4426e5c8b2b254ba5 100644
--- a/include/operator/FC.hpp
+++ b/include/operator/FC.hpp
@@ -57,7 +57,7 @@ public:
setDatatype(DataType::Float32);
}
- void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx < 3 && "operators supports only 3 inputs");
assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
if (inputIdx == 2) {
@@ -89,14 +89,14 @@ public:
inline Tensor& input(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 3 && "operators supports only 3 inputs");
return *(mInputs[inputIdx].get()); }
- inline Tensor& output(const IOIndex_t /*inputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mOutput.get()); }
inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 3 && "FC Operators supports only 3 inputs");
return mInputs[inputIdx];
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "FC Operator has only 1 output");
return mOutput;
}
@@ -106,7 +106,7 @@ public:
assert(inputIdx < 3 && "operators supports only 3 inputs");
return std::static_pointer_cast<Data>(mInputs[inputIdx]);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/GenericOperator.hpp b/include/operator/GenericOperator.hpp
index c3c8c61d7910c409f442f17deb5e4c87557ecdb3..e25fbd13f9139c8b857690ba6adc512f558f50c4 100644
--- a/include/operator/GenericOperator.hpp
+++ b/include/operator/GenericOperator.hpp
@@ -84,7 +84,7 @@ class GenericOperator_Op
std::vector<std::string> getParametersName() { return mParams.getParametersName(); }
// Override Virtual Opertor methods
- void associateInput(IOIndex_t /*inputIdx*/, std::shared_ptr<Data> /*data*/) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, __attribute__((unused)) std::shared_ptr<Data> data) override final {
printf("Info: using associateInput() on a GenericOperator.\n");
}
diff --git a/include/operator/LeakyReLU.hpp b/include/operator/LeakyReLU.hpp
index cdc1720842e88d2f815645d693786116d400356d..35a28e8356324312b2fbc14360116bc7d37baead 100644
--- a/include/operator/LeakyReLU.hpp
+++ b/include/operator/LeakyReLU.hpp
@@ -53,7 +53,7 @@ public:
setDatatype(DataType::Float32);
}
- void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx == 0 && "operator supports only 1 input");
assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
mInput = std::dynamic_pointer_cast<Tensor>(data);
@@ -69,25 +69,25 @@ public:
}
- inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { return *(mInput.get()); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
+ inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert((inputIdx == 0) && "LeakyReLU Operator has only 1 input");
return mInput;
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "LeakyReLU Operator has only 1 output");
return mOutput;
}
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
+ std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(inputIdx == 0 && "operator supports only 1 input");
return std::static_pointer_cast<Data>(mInput);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return mOutput;
}
diff --git a/include/operator/Matmul.hpp b/include/operator/Matmul.hpp
index 948cbb4ddeeecfb09402e611f72f925e640fe8db..9ecebf9d6b043a5eda011da932b58cb3e751d105 100644
--- a/include/operator/Matmul.hpp
+++ b/include/operator/Matmul.hpp
@@ -55,7 +55,7 @@ public:
setDatatype(DataType::Float32);
}
- void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx < 2 && "operators supports only 2 inputs");
assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
@@ -81,14 +81,14 @@ public:
inline Tensor& input(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 2 && "operators supports only 2 inputs");
return *(mInputs[inputIdx].get()); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
assert(inputIdx < 2 && "MatMul Operators has 2 inputs");
return mInputs[inputIdx];
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "MatMul Operators has 1 output");
return mOutput;
}
@@ -98,7 +98,7 @@ public:
assert(inputIdx < 2 && "operators supports only 2 inputs");
return std::static_pointer_cast<Data>(mInputs[inputIdx]);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/Operator.hpp b/include/operator/Operator.hpp
index 19d761841f181aad41fabf60340ea44d958d0f79..c302dca1bd3e7b39daf7dcde2a355f4811153157 100644
--- a/include/operator/Operator.hpp
+++ b/include/operator/Operator.hpp
@@ -38,7 +38,7 @@ public:
public:
- virtual void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) = 0;
+ virtual void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) = 0;
virtual void computeOutputDims() = 0;
virtual bool outputDimsForwarded() const = 0;
virtual std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const = 0;
diff --git a/include/operator/Producer.hpp b/include/operator/Producer.hpp
index fdf109681f907bc13875ec652ffa51627eabc809..58e6dd61d4d9a39535144ff57f32a36585a25a72 100644
--- a/include/operator/Producer.hpp
+++ b/include/operator/Producer.hpp
@@ -51,7 +51,7 @@ public:
setDatatype(tensor->dataType());
}
- void associateInput(IOIndex_t /*inputIdx*/, std::shared_ptr<Data> /*data*/) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, __attribute__((unused)) std::shared_ptr<Data> data) override final {
assert(false && "Producer operator takes no input");
}
@@ -60,26 +60,26 @@ public:
constexpr bool outputDimsForwarded() const override final {return true;}
- inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { assert(false); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { assert(false); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
+ inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(false && "Producer Operator has no input");
return nullptr;
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "Producer Operator has only 1 output");
return mOutput;
}
- std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
+ std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(false && "Producer operator takes no input");
return nullptr;
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/ReLU.hpp b/include/operator/ReLU.hpp
index 33583cf4bfa91a4c56d147b9321968119fe11f52..e6eddd8fdaed1667ab8f2c9d1a3e2d4f76b56bc5 100644
--- a/include/operator/ReLU.hpp
+++ b/include/operator/ReLU.hpp
@@ -42,7 +42,7 @@ public:
setDatatype(DataType::Float32);
}
- void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx == 0 && "operator supports only 1 input");
assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
mInput = std::dynamic_pointer_cast<Tensor>(data);
@@ -58,25 +58,25 @@ public:
}
- inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { return *(mInput.get()); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
+ inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert((inputIdx == 0) && "ReLU Operator has only 1 input");
return mInput;
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "ReLU Operator has only 1 output");
return mOutput;
}
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
+ std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(inputIdx == 0 && "operator supports only 1 input");
return std::static_pointer_cast<Data>(mInput);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/include/operator/Softmax.hpp b/include/operator/Softmax.hpp
index 8c35ead5ab1e74c04b350d70e6b01aae902cb782..14ec5c561282912f70d5331234e4db67de641f06 100644
--- a/include/operator/Softmax.hpp
+++ b/include/operator/Softmax.hpp
@@ -42,7 +42,7 @@ public:
setDatatype(DataType::Float32);
}
- void associateInput(IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+ void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
assert(inputIdx == 0 && "operator supports only 1 input");
assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
mInput = std::dynamic_pointer_cast<Tensor>(data);
@@ -58,25 +58,25 @@ public:
}
- inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { return *(mInput.get()); }
- inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
+ inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
+ inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
- inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
+ inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert((inputIdx == 0) && "Softmax Operator has only 1 input");
return mInput;
}
- inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
+ inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert((outputIdx == 0) && "Softmax Operator has only 1 output");
return mOutput;
}
- std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
+ std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
assert(inputIdx == 0 && "operator supports only 1 input");
return std::static_pointer_cast<Data>(mInput);
}
- std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
+ std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
assert(outputIdx == 0 && "operator supports only 1 output");
return std::static_pointer_cast<Data>(mOutput);
}
diff --git a/src/graph/GraphView.cpp b/src/graph/GraphView.cpp
index 3cce4f449de9f003346ec00ff7e7190436d2c8bd..518f1859fbb5f2864a61731b34bfb1a61b91cf8e 100644
--- a/src/graph/GraphView.cpp
+++ b/src/graph/GraphView.cpp
@@ -28,11 +28,11 @@ Aidge::Connector Aidge::GraphView::operator()(
assert((inputNodes().size() == 1U) && "Too many input Nodes for the GraphView, undefined behaviour");
std::shared_ptr<Node> inNode = *inputNodes().begin();
assert((ctors.size() == static_cast<std::size_t>(inNode->nbDataInputs())) && "Wrong number of arguments.\n");
- for (std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inNode->inputs()) {
+ for (__attribute__((unused)) std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inNode->inputs()) {
assert((gk_IODefaultIndex == input.second) && "At least one input connection is not free.\n");
}
- for (const Connector &ctor : ctors) {
+ for (__attribute__((unused)) const Connector &ctor : ctors) {
assert((ctor.node() != nullptr) &&
"Input Connector must be associated with a node");
}
diff --git a/src/graph/Node.cpp b/src/graph/Node.cpp
index 3dbc2432228f6647eb9d809843c7e6bfc95bb0ba..37cb84e4f45457308a4e52417cb2946e9418ccc4 100644
--- a/src/graph/Node.cpp
+++ b/src/graph/Node.cpp
@@ -35,7 +35,7 @@ Aidge::Node::Node(std::shared_ptr<Operator> op, const char *name)
Aidge::Connector Aidge::Node::operator()(const std::vector<Connector> ctors) {
assert((ctors.size() == nbDataInputs()) && "Wrong number of arguments.\n");
- for (std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inputs()) {
+ for (__attribute__((unused)) std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inputs()) {
assert((gk_IODefaultIndex == input.second) && "At least one input connection is not free.\n");
}
IOIndex_t i = 0;
diff --git a/src/operator/Operator.cpp b/src/operator/Operator.cpp
index 1db2feeb5e0978f78ff78a08e3d0e1ec1dceecbe..7eb9e7cdcca408680ef97cdf0f068b4992e379e5 100644
--- a/src/operator/Operator.cpp
+++ b/src/operator/Operator.cpp
@@ -27,7 +27,7 @@ Aidge::Operator::~Operator() = default;
// IMPLEMENTATION
///////////////////////////////////////////////////////
-Aidge::NbElts_t Aidge::Operator::getNbRequiredData(Aidge::IOIndex_t inputIdx) const {
+Aidge::NbElts_t Aidge::Operator::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
return mImpl->getNbRequiredData(inputIdx);
}