From c28519048ac47090be20a6faf91d1d920c033ae6 Mon Sep 17 00:00:00 2001
From: NAUD Maxence <maxence.naud@cea.fr>
Date: Tue, 1 Aug 2023 14:08:46 +0000
Subject: [PATCH] [Fix] use _attribute__((unused)) to solve unused variable
warning
---
include/backend/OperatorImpl.hpp | 2 +-
include/operator/Add.hpp | 8 ++++----
include/operator/AvgPooling.hpp | 14 +++++++-------
include/operator/BatchNorm.hpp | 8 ++++----
include/operator/Conv.hpp | 8 ++++----
include/operator/ConvDepthWise.hpp | 8 ++++----
include/operator/FC.hpp | 8 ++++----
include/operator/GenericOperator.hpp | 2 +-
include/operator/LeakyReLU.hpp | 14 +++++++-------
include/operator/Matmul.hpp | 8 ++++----
include/operator/Operator.hpp | 2 +-
include/operator/Producer.hpp | 14 +++++++-------
include/operator/ReLU.hpp | 14 +++++++-------
include/operator/Softmax.hpp | 14 +++++++-------
src/graph/GraphView.cpp | 4 ++--
src/graph/Node.cpp | 2 +-
src/operator/Operator.cpp | 2 +-
17 files changed, 66 insertions(+), 66 deletions(-)
diff --git a/include/backend/OperatorImpl.hpp b/include/backend/OperatorImpl.hpp
index a2c97c607..4cf6eef60 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 42720af85..fc2dc8a47 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 c3321dc24..35a401fef 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 d46f971f1..9499cff11 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 2e9f67df5..1de05af0b 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 fa268a32e..c9a0e6b01 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 998957909..240210f40 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 c3c8c61d7..e25fbd13f 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 cdc172084..35a28e835 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 948cbb4dd..9ecebf9d6 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 19d761841..c302dca1b 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 fdf109681..58e6dd61d 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 33583cf4b..e6eddd8fd 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 8c35ead5a..14ec5c561 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 3cce4f449..518f1859f 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 3dbc24322..37cb84e4f 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 1db2feeb5..7eb9e7cdc 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);
}
--
GitLab