COMPMID-1674: (3RDPARTY_UPDATE) Add FullyConnectedLayer Dragonbench

Change-Id: I3c3e96a743614af4c2c2391780d5de2db6191b0f
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/155318
Tested-by: bsgcomp <bsgcomp@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>
Reviewed-by: Pablo Tello <pablo.tello@arm.com>

5 files changed, 183 insertions, 38 deletions

diff --git a/tests/benchmark/CL/DragonBench.cpp b/tests/benchmark/CL/DragonBench.cpp
index 958639894f..250b25aeee 100644
--- a/tests/benchmark/CL/DragonBench.cpp
+++ b/tests/benchmark/CL/DragonBench.cpp
@@ -28,6 +28,9 @@
 #include "arm_compute/runtime/CL/CLTensor.h"
 #include "arm_compute/runtime/CL/CLTensorAllocator.h"
 #include "arm_compute/runtime/CL/functions/CLConvolutionLayer.h"
+#include "arm_compute/runtime/CL/functions/CLFullyConnectedLayer.h"
+
+#include "tests/benchmark/DragonBenchConfigs.h"
 
 #include "tests/CL/CLAccessor.h"
 #include "tests/benchmark/fixtures/DragonBenchFixture.h"
@@ -36,8 +39,6 @@
 #include "tests/framework/datasets/Datasets.h"
 #include "utils/TypePrinter.h"
 
-#include "tests/benchmark/DragonBenchConfigs.h"
-
 namespace arm_compute
 {
 namespace test
@@ -46,54 +47,67 @@ namespace benchmark
 {
 namespace
 {
+// Common parameters
+const auto data_types = framework::dataset::make("DataType", { DataType::QASYMM8, DataType::F16, DataType::F32 });
+
 // Common DragonBench parameters
-auto CommonParamsNoBias = combine(combine(framework::dataset::make("DataType", { DataType::QASYMM8, DataType::F16, DataType::F32 }),
-                                          framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
-                                  framework::dataset::make("HasBias", { false }));
-auto CommonParamsBias = combine(combine(framework::dataset::make("DataType", { DataType::QASYMM8, DataType::F16, DataType::F32 }),
-                                        framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
-                                framework::dataset::make("HasBias", { true }));
-} // namespace
+auto CommonConv2DParamsNoBias = combine(combine(data_types, framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
+                                        framework::dataset::make("HasBias", { false }));
+auto CommonConv2DParamsBias = combine(combine(data_types, framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
+                                      framework::dataset::make("HasBias", { true }));
 
-using CLDragonBenchConv2DFixture = DragonBenchConv2DFixture<CLTensor, CLConvolutionLayer, CLAccessor, Conv2D>;
+// Common DragonBench FC parameters
+auto CommonFCParams = combine(data_types, framework::dataset::make("HasBias", { false }));
+} // namespace
 
 TEST_SUITE(CL)
 TEST_SUITE(DragonBench)
+
 TEST_SUITE(Conv2D)
+using CLDragonBenchConv2DFixture = DragonBenchConv2DFixture<CLTensor, CLConvolutionLayer, CLAccessor, Conv2D>;
 
 REGISTER_FIXTURE_DATA_TEST_CASE(SilverWing,
                                 CLDragonBenchConv2DFixture,
                                 framework::DatasetMode::ALL,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonParamsNoBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonConv2DParamsNoBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(SunFyre,
                                 CLDragonBenchConv2DFixture,
                                 framework::DatasetMode::ALL,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonParamsNoBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonConv2DParamsNoBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(Syrax,
                                 CLDragonBenchConv2DFixture,
                                 framework::DatasetMode::ALL,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonParamsNoBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonConv2DParamsNoBias));
 
 TEST_SUITE(Nightly)
 REGISTER_FIXTURE_DATA_TEST_CASE(SilverWing,
                                 CLDragonBenchConv2DFixture,
                                 framework::DatasetMode::NIGHTLY,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonParamsBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonConv2DParamsBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(SunFyre,
                                 CLDragonBenchConv2DFixture,
                                 framework::DatasetMode::NIGHTLY,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonParamsBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonConv2DParamsBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(Syrax,
                                 CLDragonBenchConv2DFixture,
                                 framework::DatasetMode::NIGHTLY,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonParamsBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonConv2DParamsBias));
 TEST_SUITE_END() // Nightly
-
 TEST_SUITE_END() // Conv2D
+
+TEST_SUITE(FullyConnected)
+using CLDragonBenchFCFixture = DragonBenchFCFixture<CLTensor, CLFullyConnectedLayer, CLAccessor, Fully_Connected>;
+
+REGISTER_FIXTURE_DATA_TEST_CASE(DreamFyre,
+                                CLDragonBenchFCFixture,
+                                framework::DatasetMode::ALL,
+                                combine(datasets::DragonBenchDataset<Fully_Connected_Configs, Fully_Connected>(dreamfyre_cfgs), CommonFCParams));
+TEST_SUITE_END() // FullyConnected
+
 TEST_SUITE_END() // DragonBench
 TEST_SUITE_END() // CL
 } // namespace benchmark
diff --git a/tests/benchmark/DragonBenchConfigs.cpp b/tests/benchmark/DragonBenchConfigs.cpp
index 4ba7fe7f96..2f0a62caab 100644
--- a/tests/benchmark/DragonBenchConfigs.cpp
+++ b/tests/benchmark/DragonBenchConfigs.cpp
@@ -32,11 +32,16 @@ namespace test
 {
 namespace benchmark
 {
-#include "dragonbench/conv2d.hpp"
+#include "dragonbench/conv2d/conv2d.hpp"
+#include "dragonbench/fully_connected/fully_connected.hpp"
 
-#include "dragonbench/silverwing/silverwing_configs.hpp"
-#include "dragonbench/sunfyre/sunfyre_configs.hpp"
-#include "dragonbench/syrax/syrax_configs.hpp"
+// Conv2D
+#include "dragonbench/conv2d/silverwing/silverwing_configs.hpp"
+#include "dragonbench/conv2d/sunfyre/sunfyre_configs.hpp"
+#include "dragonbench/conv2d/syrax/syrax_configs.hpp"
+
+// Fully Connected
+#include "dragonbench/fully_connected/dreamfyre/dreamfyre_configs.hpp"
 } // namespace benchmark
 } // namespace test
 } // namespace arm_compute
diff --git a/tests/benchmark/DragonBenchConfigs.h b/tests/benchmark/DragonBenchConfigs.h
index c12a22c8ae..4fe6c79ae8 100644
--- a/tests/benchmark/DragonBenchConfigs.h
+++ b/tests/benchmark/DragonBenchConfigs.h
@@ -28,10 +28,59 @@
 #include <string>
 #include <vector>
 
-#include "dragonbench/conv2d.hpp"
+#include "dragonbench/conv2d/conv2d.hpp"
+#include "dragonbench/fully_connected/fully_connected.hpp"
 
 namespace arm_compute
 {
+// Stream operators
+inline ::std::ostream &operator<<(::std::ostream &os, const Conv2D &conv2d_config)
+{
+    os << "network_name=" << conv2d_config.network_name << ":";
+    os << "layer_name=" << conv2d_config.layer_name << ":";
+    os << "id=" << conv2d_config.id << ":";
+    os << "Input_NCHW="
+       << conv2d_config.ibatch << ','
+       << conv2d_config.ch_in << ','
+       << conv2d_config.dim_in_h << ','
+       << conv2d_config.dim_in_w << ":";
+    os << "Output_NCHW="
+       << conv2d_config.ibatch << ','
+       << conv2d_config.ch_out << ','
+       << conv2d_config.dim_out_h << ','
+       << conv2d_config.dim_out_w << ":";
+    os << "Weights_HW="
+       << conv2d_config.kern_h << ','
+       << conv2d_config.kern_w << ":";
+    os << "Stride_HW="
+       << conv2d_config.stride_h << ','
+       << conv2d_config.stride_w << ":";
+    os << "Padding=" << conv2d_config.padding << ":";
+    return os;
+}
+inline std::string to_string(const Conv2D &conv2d_config)
+{
+    std::stringstream str;
+    str << conv2d_config;
+    return str.str();
+}
+inline ::std::ostream &operator<<(::std::ostream &os, const Fully_Connected &fc_config)
+{
+    os << "network_name=" << fc_config.network_name << ":";
+    os << "layer_name=" << fc_config.layer_name << ":";
+    os << "id=" << fc_config.id << ":";
+    os << "M=" << fc_config.m << ":";
+    os << "N=" << fc_config.n << ":";
+    os << "K=" << fc_config.k << ":";
+    return os;
+}
+inline std::string to_string(const Fully_Connected &fc_config)
+{
+    std::stringstream str;
+    str << fc_config;
+    return str.str();
+}
+
 namespace test
 {
 namespace benchmark
@@ -40,6 +89,9 @@ namespace benchmark
 extern conv2d_configs silverwing_cfgs;
 extern conv2d_configs sunfyre_cfgs;
 extern conv2d_configs syrax_cfgs;
+
+// Fully Connected benchmarks
+extern fully_connected_configs dreamfyre_cfgs;
 } // namespace benchmark
 } // namespace test
 } // namespace arm_compute
diff --git a/tests/benchmark/NEON/DragonBench.cpp b/tests/benchmark/NEON/DragonBench.cpp
index 33e6939b24..37638584da 100644
--- a/tests/benchmark/NEON/DragonBench.cpp
+++ b/tests/benchmark/NEON/DragonBench.cpp
@@ -26,9 +26,12 @@
 #include "arm_compute/core/TensorShape.h"
 #include "arm_compute/core/Types.h"
 #include "arm_compute/runtime/NEON/functions/NEConvolutionLayer.h"
+#include "arm_compute/runtime/NEON/functions/NEFullyConnectedLayer.h"
 #include "arm_compute/runtime/Tensor.h"
 #include "arm_compute/runtime/TensorAllocator.h"
 
+#include "tests/benchmark/DragonBenchConfigs.h"
+
 #include "tests/NEON/Accessor.h"
 #include "tests/benchmark/fixtures/DragonBenchFixture.h"
 #include "tests/datasets/DragonBenchDataset.h"
@@ -36,8 +39,6 @@
 #include "tests/framework/datasets/Datasets.h"
 #include "utils/TypePrinter.h"
 
-#include "tests/benchmark/DragonBenchConfigs.h"
-
 namespace arm_compute
 {
 namespace test
@@ -52,52 +53,64 @@ const auto data_types = framework::dataset::make("DataType", { DataType::QASYMM8
 const auto data_types = framework::dataset::make("DataType", { DataType::QASYMM8, DataType::F32 });
 #endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
 
-// Common DragonBench parameters
-auto CommonParamsNoBias = combine(combine(data_types, framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
-                                  framework::dataset::make("HasBias", { false }));
-auto CommonParamsBias = combine(combine(data_types, framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
-                                framework::dataset::make("HasBias", { true }));
-} // namespace
+// Common DragonBench Conv2D parameters
+auto CommonConv2DParamsNoBias = combine(combine(data_types, framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
+                                        framework::dataset::make("HasBias", { false }));
+auto CommonConv2DParamsBias = combine(combine(data_types, framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
+                                      framework::dataset::make("HasBias", { true }));
 
-using NEDragonBenchConv2DFixture = DragonBenchConv2DFixture<Tensor, NEConvolutionLayer, Accessor, Conv2D>;
+// Common DragonBench FC parameters
+auto CommonFCParams = combine(data_types, framework::dataset::make("HasBias", { false }));
+} // namespace
 
 TEST_SUITE(NEON)
 TEST_SUITE(DragonBench)
+
 TEST_SUITE(Conv2D)
+using NEDragonBenchConv2DFixture = DragonBenchConv2DFixture<Tensor, NEConvolutionLayer, Accessor, Conv2D>;
 
 REGISTER_FIXTURE_DATA_TEST_CASE(SilverWing,
                                 NEDragonBenchConv2DFixture,
                                 framework::DatasetMode::ALL,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonParamsNoBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonConv2DParamsNoBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(SunFyre,
                                 NEDragonBenchConv2DFixture,
                                 framework::DatasetMode::ALL,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonParamsNoBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonConv2DParamsNoBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(Syrax,
                                 NEDragonBenchConv2DFixture,
                                 framework::DatasetMode::ALL,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonParamsNoBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonConv2DParamsNoBias));
 
 TEST_SUITE(Nightly)
 REGISTER_FIXTURE_DATA_TEST_CASE(SilverWing,
                                 NEDragonBenchConv2DFixture,
                                 framework::DatasetMode::NIGHTLY,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonParamsBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(silverwing_cfgs), CommonConv2DParamsBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(SunFyre,
                                 NEDragonBenchConv2DFixture,
                                 framework::DatasetMode::NIGHTLY,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonParamsBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(sunfyre_cfgs), CommonConv2DParamsBias));
 
 REGISTER_FIXTURE_DATA_TEST_CASE(Syrax,
                                 NEDragonBenchConv2DFixture,
                                 framework::DatasetMode::NIGHTLY,
-                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonParamsBias));
+                                combine(datasets::DragonBenchDataset<Conv2D_Configs, Conv2D>(syrax_cfgs), CommonConv2DParamsBias));
 TEST_SUITE_END() // Nightly
-
 TEST_SUITE_END() // Conv2D
+
+TEST_SUITE(FullyConnected)
+using NEDragonBenchFCFixture = DragonBenchFCFixture<Tensor, NEFullyConnectedLayer, Accessor, Fully_Connected>;
+
+REGISTER_FIXTURE_DATA_TEST_CASE(DreamFyre,
+                                NEDragonBenchFCFixture,
+                                framework::DatasetMode::ALL,
+                                combine(datasets::DragonBenchDataset<Fully_Connected_Configs, Fully_Connected>(dreamfyre_cfgs), CommonFCParams));
+TEST_SUITE_END() // FullyConnected
+
 TEST_SUITE_END() // DragonBench
 TEST_SUITE_END() // NEON
 } // namespace benchmark
diff --git a/tests/benchmark/fixtures/DragonBenchFixture.h b/tests/benchmark/fixtures/DragonBenchFixture.h
index 526a798154..bb93a46cf5 100644
--- a/tests/benchmark/fixtures/DragonBenchFixture.h
+++ b/tests/benchmark/fixtures/DragonBenchFixture.h
@@ -113,6 +113,67 @@ private:
     TensorType dst{};
     Function   conv_layer{};
 };
+
+/** Fixture that can be used for NEON and CL */
+template <typename TensorType, typename Function, typename Accessor, typename FullyConnectedConfig>
+class DragonBenchFCFixture : public framework::Fixture
+{
+public:
+    template <typename...>
+    void setup(FullyConnectedConfig config, DataType data_type, bool has_bias)
+    {
+        // Set tensor shapes in NCHW layout
+        TensorShape src_shape(config.k, config.m);
+        TensorShape weights_shape(config.k, config.n);
+        TensorShape biases_shape(config.n);
+        TensorShape dst_shape(config.n, config.m);
+
+        // Determine bias data type
+        DataType               bias_data_type = is_data_type_quantized_asymmetric(data_type) ? DataType::S32 : data_type;
+        const QuantizationInfo q_info(2.f, 10);
+
+        // Create tensors
+        src     = create_tensor<TensorType>(src_shape, data_type, 1, q_info);
+        weights = create_tensor<TensorType>(weights_shape, data_type, 1, q_info);
+        biases  = create_tensor<TensorType>(biases_shape, bias_data_type, 1, q_info);
+        dst     = create_tensor<TensorType>(dst_shape, data_type, 1, q_info);
+
+        // Create and configure function
+        fc_layer.configure(&src, &weights, has_bias ? &biases : nullptr, &dst);
+
+        // Allocate tensors
+        src.allocator()->allocate();
+        weights.allocator()->allocate();
+        biases.allocator()->allocate();
+        dst.allocator()->allocate();
+    }
+
+    void run()
+    {
+        fc_layer.run();
+    }
+
+    void sync()
+    {
+        sync_if_necessary<TensorType>();
+        sync_tensor_if_necessary<TensorType>(dst);
+    }
+
+    void teardown()
+    {
+        src.allocator()->free();
+        weights.allocator()->free();
+        biases.allocator()->free();
+        dst.allocator()->free();
+    }
+
+private:
+    TensorType src{};
+    TensorType weights{};
+    TensorType biases{};
+    TensorType dst{};
+    Function   fc_layer{};
+};
 } // namespace benchmark
 } // namespace test
 } // namespace arm_compute