From afd38f0c617d6f89b2b4532c6c44f116617e2b6f Mon Sep 17 00:00:00 2001 From: Felix Thomasmathibalan Date: Wed, 27 Sep 2023 17:46:17 +0100 Subject: Apply clang-format on repository Code is formatted as per a revised clang format configuration file(not part of this delivery). Version 14.0.6 is used. Exclusion List: - files with .cl extension - files that are not strictly C/C++ (e.g. Android.bp, Sconscript ...) And the following directories - compute_kernel_writer/validation/ - tests/ - include/ - src/core/NEON/kernels/convolution/ - src/core/NEON/kernels/arm_gemm/ - src/core/NEON/kernels/arm_conv/ - data/ There will be a follow up for formatting of .cl files and the files under tests/ and compute_kernel_writer/validation/. Signed-off-by: Felix Thomasmathibalan Change-Id: Ib7eb1fcf4e7537b9feaefcfc15098a804a3fde0a Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/10391 Benchmark: Arm Jenkins Tested-by: Arm Jenkins Reviewed-by: Gunes Bayir --- utils/CommonGraphOptions.cpp | 76 +++++----- utils/CommonGraphOptions.h | 30 ++-- utils/GraphUtils.cpp | 246 +++++++++++++++--------------- utils/GraphUtils.h | 106 +++++++------ utils/ImageLoader.h | 146 +++++++++--------- utils/TypePrinter.h | 267 +++++++++++++++------------------ utils/Utils.cpp | 61 ++++---- utils/Utils.h | 230 +++++++++++++++------------- utils/command_line/CommandLineParser.h | 54 +++---- utils/command_line/EnumListOption.h | 25 +-- utils/command_line/EnumOption.h | 17 +-- utils/command_line/ListOption.h | 13 +- utils/command_line/Option.h | 9 +- utils/command_line/SimpleOption.h | 7 +- utils/command_line/ToggleOption.h | 12 +- 15 files changed, 653 insertions(+), 646 deletions(-) (limited to 'utils') diff --git a/utils/CommonGraphOptions.cpp b/utils/CommonGraphOptions.cpp index c0270726da..42524d802d 100644 --- a/utils/CommonGraphOptions.cpp +++ b/utils/CommonGraphOptions.cpp @@ -37,15 +37,15 @@ namespace { std::pair parse_validation_range(const std::string &validation_range) { - std::pair range = { 0, std::numeric_limits::max() }; - if(!validation_range.empty()) + std::pair range = {0, std::numeric_limits::max()}; + if (!validation_range.empty()) { std::string str; std::stringstream stream(validation_range); // Get first value std::getline(stream, str, ','); - if(stream.fail()) + if (stream.fail()) { return range; } @@ -56,7 +56,7 @@ std::pair parse_validation_range(const std::string & // Get second value std::getline(stream, str); - if(stream.fail()) + if (stream.fail()) { range.second = range.first; return range; @@ -88,24 +88,26 @@ namespace utils os << "Tuner mode : " << common_params.tuner_mode << std::endl; os << "Tuner file : " << common_params.tuner_file << std::endl; os << "MLGO file : " << common_params.mlgo_file << std::endl; - os << "Fast math enabled? : " << (common_params.fast_math_hint == FastMathHint::Enabled ? true_str : false_str) << std::endl; - if(!common_params.data_path.empty()) + os << "Fast math enabled? : " << (common_params.fast_math_hint == FastMathHint::Enabled ? true_str : false_str) + << std::endl; + if (!common_params.data_path.empty()) { os << "Data path : " << common_params.data_path << std::endl; } - if(!common_params.image.empty()) + if (!common_params.image.empty()) { os << "Image file : " << common_params.image << std::endl; } - if(!common_params.labels.empty()) + if (!common_params.labels.empty()) { os << "Labels file : " << common_params.labels << std::endl; } - if(!common_params.validation_file.empty()) + if (!common_params.validation_file.empty()) { - os << "Validation range : " << common_params.validation_range_start << "-" << common_params.validation_range_end << std::endl; + os << "Validation range : " << common_params.validation_range_start << "-" << common_params.validation_range_end + << std::endl; os << "Validation file : " << common_params.validation_file << std::endl; - if(!common_params.validation_path.empty()) + if (!common_params.validation_path.empty()) { os << "Validation path : " << common_params.validation_path << std::endl; } @@ -134,33 +136,25 @@ CommonGraphOptions::CommonGraphOptions(CommandLineParser &parser) tuner_file(parser.add_option>("tuner-file")), mlgo_file(parser.add_option>("mlgo-file")) { - std::set supported_targets - { + std::set supported_targets{ Target::NEON, Target::CL, Target::CLVK, }; - std::set supported_data_types - { + std::set supported_data_types{ DataType::F16, DataType::F32, DataType::QASYMM8, DataType::QASYMM8_SIGNED, }; - std::set supported_data_layouts - { + std::set supported_data_layouts{ DataLayout::NHWC, DataLayout::NCHW, }; - const std::set supported_tuner_modes - { - CLTunerMode::EXHAUSTIVE, - CLTunerMode::NORMAL, - CLTunerMode::RAPID - }; + const std::set supported_tuner_modes{CLTunerMode::EXHAUSTIVE, CLTunerMode::NORMAL, CLTunerMode::RAPID}; target = parser.add_option>("target", supported_targets, Target::NEON); data_type = parser.add_option>("type", supported_data_types, DataType::F32); @@ -175,11 +169,10 @@ CommonGraphOptions::CommonGraphOptions(CommandLineParser &parser) data_layout->set_help("Data layout to use"); enable_tuner->set_help("Enable OpenCL dynamic tuner"); enable_cl_cache->set_help("Enable OpenCL program caches"); - tuner_mode->set_help( - "Configures the time taken by the tuner to tune. " - "Exhaustive: slowest but produces the most performant LWS configuration. " - "Normal: slow but produces the LWS configurations on par with Exhaustive most of the time. " - "Rapid: fast but produces less performant LWS configurations"); + tuner_mode->set_help("Configures the time taken by the tuner to tune. " + "Exhaustive: slowest but produces the most performant LWS configuration. " + "Normal: slow but produces the LWS configurations on par with Exhaustive most of the time. " + "Rapid: fast but produces less performant LWS configurations"); fast_math_hint->set_help("Enable fast math"); data_path->set_help("Path where graph parameters reside"); image->set_help("Input image for the graph"); @@ -193,8 +186,9 @@ CommonGraphOptions::CommonGraphOptions(CommandLineParser &parser) CommonGraphParams consume_common_graph_parameters(CommonGraphOptions &options) { - FastMathHint fast_math_hint_value = options.fast_math_hint->value() ? FastMathHint::Enabled : FastMathHint::Disabled; - auto validation_range = parse_validation_range(options.validation_range->value()); + FastMathHint fast_math_hint_value = + options.fast_math_hint->value() ? FastMathHint::Enabled : FastMathHint::Disabled; + auto validation_range = parse_validation_range(options.validation_range->value()); CommonGraphParams common_params; common_params.help = options.help->is_set() ? options.help->value() : false; @@ -202,19 +196,21 @@ CommonGraphParams consume_common_graph_parameters(CommonGraphOptions &options) common_params.batches = options.batches->value(); common_params.target = options.target->value(); common_params.data_type = options.data_type->value(); - if(options.data_layout->is_set()) + if (options.data_layout->is_set()) { common_params.data_layout = options.data_layout->value(); } - common_params.enable_tuner = options.enable_tuner->is_set() ? options.enable_tuner->value() : false; - common_params.enable_cl_cache = common_params.target == arm_compute::graph::Target::NEON ? false : (options.enable_cl_cache->is_set() ? options.enable_cl_cache->value() : true); - common_params.tuner_mode = options.tuner_mode->value(); - common_params.fast_math_hint = options.fast_math_hint->is_set() ? fast_math_hint_value : FastMathHint::Disabled; - common_params.data_path = options.data_path->value(); - common_params.image = options.image->value(); - common_params.labels = options.labels->value(); - common_params.validation_file = options.validation_file->value(); - common_params.validation_path = options.validation_path->value(); + common_params.enable_tuner = options.enable_tuner->is_set() ? options.enable_tuner->value() : false; + common_params.enable_cl_cache = common_params.target == arm_compute::graph::Target::NEON + ? false + : (options.enable_cl_cache->is_set() ? options.enable_cl_cache->value() : true); + common_params.tuner_mode = options.tuner_mode->value(); + common_params.fast_math_hint = options.fast_math_hint->is_set() ? fast_math_hint_value : FastMathHint::Disabled; + common_params.data_path = options.data_path->value(); + common_params.image = options.image->value(); + common_params.labels = options.labels->value(); + common_params.validation_file = options.validation_file->value(); + common_params.validation_path = options.validation_path->value(); common_params.validation_range_start = validation_range.first; common_params.validation_range_end = validation_range.second; common_params.tuner_file = options.tuner_file->value(); diff --git a/utils/CommonGraphOptions.h b/utils/CommonGraphOptions.h index afdb78b1be..c42e06cb84 100644 --- a/utils/CommonGraphOptions.h +++ b/utils/CommonGraphOptions.h @@ -24,13 +24,13 @@ #ifndef ARM_COMPUTE_EXAMPLES_UTILS_COMMON_GRAPH_OPTIONS #define ARM_COMPUTE_EXAMPLES_UTILS_COMMON_GRAPH_OPTIONS -#include "utils/command_line/CommandLineOptions.h" -#include "utils/command_line/CommandLineParser.h" - #include "arm_compute/graph/TypeLoader.h" #include "arm_compute/graph/TypePrinter.h" #include "arm_compute/runtime/CL/CLTunerTypes.h" +#include "utils/command_line/CommandLineOptions.h" +#include "utils/command_line/CommandLineParser.h" + namespace arm_compute { namespace utils @@ -92,16 +92,16 @@ namespace utils /** Structure holding all the common graph parameters */ struct CommonGraphParams { - bool help{ false }; - int threads{ 0 }; - int batches{ 1 }; - arm_compute::graph::Target target{ arm_compute::graph::Target::NEON }; - arm_compute::DataType data_type{ DataType::F32 }; - arm_compute::DataLayout data_layout{ DataLayout::NHWC }; - bool enable_tuner{ false }; - bool enable_cl_cache{ false }; - arm_compute::CLTunerMode tuner_mode{ CLTunerMode::NORMAL }; - arm_compute::graph::FastMathHint fast_math_hint{ arm_compute::graph::FastMathHint::Disabled }; + bool help{false}; + int threads{0}; + int batches{1}; + arm_compute::graph::Target target{arm_compute::graph::Target::NEON}; + arm_compute::DataType data_type{DataType::F32}; + arm_compute::DataLayout data_layout{DataLayout::NHWC}; + bool enable_tuner{false}; + bool enable_cl_cache{false}; + arm_compute::CLTunerMode tuner_mode{CLTunerMode::NORMAL}; + arm_compute::graph::FastMathHint fast_math_hint{arm_compute::graph::FastMathHint::Disabled}; std::string data_path{}; std::string image{}; std::string labels{}; @@ -109,8 +109,8 @@ struct CommonGraphParams std::string validation_path{}; std::string tuner_file{}; std::string mlgo_file{}; - unsigned int validation_range_start{ 0 }; - unsigned int validation_range_end{ std::numeric_limits::max() }; + unsigned int validation_range_start{0}; + unsigned int validation_range_end{std::numeric_limits::max()}; }; /** Formatted output of the CommonGraphParams type diff --git a/utils/GraphUtils.cpp b/utils/GraphUtils.cpp index c3f71299f6..ca8e14abba 100644 --- a/utils/GraphUtils.cpp +++ b/utils/GraphUtils.cpp @@ -43,18 +43,21 @@ using namespace arm_compute::graph_utils; namespace { -std::pair compute_permutation_parameters(const arm_compute::TensorShape &shape, - arm_compute::DataLayout data_layout) +std::pair +compute_permutation_parameters(const arm_compute::TensorShape &shape, arm_compute::DataLayout data_layout) { // Set permutation parameters if needed arm_compute::TensorShape permuted_shape = shape; arm_compute::PermutationVector perm; // Permute only if num_dimensions greater than 2 - if(shape.num_dimensions() > 2) + if (shape.num_dimensions() > 2) { - perm = (data_layout == arm_compute::DataLayout::NHWC) ? arm_compute::PermutationVector(2U, 0U, 1U) : arm_compute::PermutationVector(1U, 2U, 0U); + perm = (data_layout == arm_compute::DataLayout::NHWC) ? arm_compute::PermutationVector(2U, 0U, 1U) + : arm_compute::PermutationVector(1U, 2U, 0U); - arm_compute::PermutationVector perm_shape = (data_layout == arm_compute::DataLayout::NCHW) ? arm_compute::PermutationVector(2U, 0U, 1U) : arm_compute::PermutationVector(1U, 2U, 0U); + arm_compute::PermutationVector perm_shape = (data_layout == arm_compute::DataLayout::NCHW) + ? arm_compute::PermutationVector(2U, 0U, 1U) + : arm_compute::PermutationVector(1U, 2U, 0U); arm_compute::permute(permuted_shape, perm_shape); } @@ -62,17 +65,16 @@ std::pair compute_perm } } // namespace -TFPreproccessor::TFPreproccessor(float min_range, float max_range) - : _min_range(min_range), _max_range(max_range) +TFPreproccessor::TFPreproccessor(float min_range, float max_range) : _min_range(min_range), _max_range(max_range) { } void TFPreproccessor::preprocess(ITensor &tensor) { - if(tensor.info()->data_type() == DataType::F32) + if (tensor.info()->data_type() == DataType::F32) { preprocess_typed(tensor); } - else if(tensor.info()->data_type() == DataType::F16) + else if (tensor.info()->data_type() == DataType::F16) { preprocess_typed(tensor); } @@ -89,19 +91,20 @@ void TFPreproccessor::preprocess_typed(ITensor &tensor) window.use_tensor_dimensions(tensor.info()->tensor_shape()); const float range = _max_range - _min_range; - execute_window_loop(window, [&](const Coordinates & id) - { - const T value = *reinterpret_cast(tensor.ptr_to_element(id)); - float res = value / 255.f; // Normalize to [0, 1] - res = res * range + _min_range; // Map to [min_range, max_range] - *reinterpret_cast(tensor.ptr_to_element(id)) = res; - }); + execute_window_loop(window, + [&](const Coordinates &id) + { + const T value = *reinterpret_cast(tensor.ptr_to_element(id)); + float res = value / 255.f; // Normalize to [0, 1] + res = res * range + _min_range; // Map to [min_range, max_range] + *reinterpret_cast(tensor.ptr_to_element(id)) = res; + }); } CaffePreproccessor::CaffePreproccessor(std::array mean, bool bgr, float scale) : _mean(mean), _bgr(bgr), _scale(scale) { - if(_bgr) + if (_bgr) { std::swap(_mean[0], _mean[2]); } @@ -109,11 +112,11 @@ CaffePreproccessor::CaffePreproccessor(std::array mean, bool bgr, floa void CaffePreproccessor::preprocess(ITensor &tensor) { - if(tensor.info()->data_type() == DataType::F32) + if (tensor.info()->data_type() == DataType::F32) { preprocess_typed(tensor); } - else if(tensor.info()->data_type() == DataType::F16) + else if (tensor.info()->data_type() == DataType::F16) { preprocess_typed(tensor); } @@ -130,15 +133,16 @@ void CaffePreproccessor::preprocess_typed(ITensor &tensor) window.use_tensor_dimensions(tensor.info()->tensor_shape()); const int channel_idx = get_data_layout_dimension_index(tensor.info()->data_layout(), DataLayoutDimension::CHANNEL); - execute_window_loop(window, [&](const Coordinates & id) - { - const T value = *reinterpret_cast(tensor.ptr_to_element(id)) - T(_mean[id[channel_idx]]); - *reinterpret_cast(tensor.ptr_to_element(id)) = value * T(_scale); - }); + execute_window_loop(window, + [&](const Coordinates &id) + { + const T value = + *reinterpret_cast(tensor.ptr_to_element(id)) - T(_mean[id[channel_idx]]); + *reinterpret_cast(tensor.ptr_to_element(id)) = value * T(_scale); + }); } -PPMWriter::PPMWriter(std::string name, unsigned int maximum) - : _name(std::move(name)), _iterator(0), _maximum(maximum) +PPMWriter::PPMWriter(std::string name, unsigned int maximum) : _name(std::move(name)), _iterator(0), _maximum(maximum) { } @@ -150,15 +154,14 @@ bool PPMWriter::access_tensor(ITensor &tensor) arm_compute::utils::save_to_ppm(tensor, ss.str()); _iterator++; - if(_maximum == 0) + if (_maximum == 0) { return true; } return _iterator < _maximum; } -DummyAccessor::DummyAccessor(unsigned int maximum) - : _iterator(0), _maximum(maximum) +DummyAccessor::DummyAccessor(unsigned int maximum) : _iterator(0), _maximum(maximum) { } @@ -171,7 +174,7 @@ bool DummyAccessor::access_tensor(ITensor &tensor) { ARM_COMPUTE_UNUSED(tensor); bool ret = _maximum == 0 || _iterator < _maximum; - if(_iterator == _maximum) + if (_iterator == _maximum) { _iterator = 0; } @@ -182,7 +185,8 @@ bool DummyAccessor::access_tensor(ITensor &tensor) return ret; } -NumPyAccessor::NumPyAccessor(std::string npy_path, TensorShape shape, DataType data_type, DataLayout data_layout, std::ostream &output_stream) +NumPyAccessor::NumPyAccessor( + std::string npy_path, TensorShape shape, DataType data_type, DataLayout data_layout, std::ostream &output_stream) : _npy_tensor(), _filename(std::move(npy_path)), _output_stream(output_stream) { NumPyBinLoader loader(_filename, data_layout); @@ -203,8 +207,10 @@ void NumPyAccessor::access_numpy_tensor(ITensor &tensor, T tolerance) int num_mismatches = utils::compare_tensor(tensor, _npy_tensor, tolerance); float percentage_mismatches = static_cast(num_mismatches) / num_elements; - _output_stream << "Results: " << 100.f - (percentage_mismatches * 100) << " % matches with the provided output[" << _filename << "]." << std::endl; - _output_stream << " " << num_elements - num_mismatches << " out of " << num_elements << " matches with the provided output[" << _filename << "]." << std::endl + _output_stream << "Results: " << 100.f - (percentage_mismatches * 100) << " % matches with the provided output[" + << _filename << "]." << std::endl; + _output_stream << " " << num_elements - num_mismatches << " out of " << num_elements + << " matches with the provided output[" << _filename << "]." << std::endl << std::endl; } @@ -213,7 +219,7 @@ bool NumPyAccessor::access_tensor(ITensor &tensor) ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&tensor, 1, DataType::F32, DataType::QASYMM8); ARM_COMPUTE_ERROR_ON(_npy_tensor.info()->dimension(0) != tensor.info()->dimension(0)); - switch(tensor.info()->data_type()) + switch (tensor.info()->data_type()) { case DataType::QASYMM8: access_numpy_tensor(tensor, 0); @@ -262,7 +268,7 @@ ImageAccessor::ImageAccessor(std::string filename, bool bgr, std::unique_ptrtensor_shape(); arm_compute::PermutationVector perm; - if(tensor.info()->data_layout() != DataLayout::NCHW) + if (tensor.info()->data_layout() != DataLayout::NCHW) { - std::tie(permuted_shape, perm) = compute_permutation_parameters(tensor.info()->tensor_shape(), tensor.info()->data_layout()); + std::tie(permuted_shape, perm) = + compute_permutation_parameters(tensor.info()->tensor_shape(), tensor.info()->data_layout()); } #ifdef __arm__ - ARM_COMPUTE_EXIT_ON_MSG_VAR(image_loader->width() != permuted_shape.x() || image_loader->height() != permuted_shape.y(), - "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu32 ",%" PRIu32 "].", - image_loader->width(), image_loader->height(), permuted_shape.x(), permuted_shape.y()); + ARM_COMPUTE_EXIT_ON_MSG_VAR( + image_loader->width() != permuted_shape.x() || image_loader->height() != permuted_shape.y(), + "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu32 ",%" PRIu32 "].", + image_loader->width(), image_loader->height(), permuted_shape.x(), permuted_shape.y()); #else // __arm__ - ARM_COMPUTE_EXIT_ON_MSG_VAR(image_loader->width() != permuted_shape.x() || image_loader->height() != permuted_shape.y(), - "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu64 ",%" PRIu64 "].", - image_loader->width(), image_loader->height(), - static_cast(permuted_shape.x()), static_cast(permuted_shape.y())); + ARM_COMPUTE_EXIT_ON_MSG_VAR( + image_loader->width() != permuted_shape.x() || image_loader->height() != permuted_shape.y(), + "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu64 ",%" PRIu64 "].", + image_loader->width(), image_loader->height(), static_cast(permuted_shape.x()), + static_cast(permuted_shape.y())); #endif // __arm__ // Fill the tensor with the PPM content (BGR) image_loader->fill_planar_tensor(tensor, _bgr); // Preprocess tensor - if(_preprocessor) + if (_preprocessor) { _preprocessor->preprocess(tensor); } @@ -310,7 +319,12 @@ ValidationInputAccessor::ValidationInputAccessor(const std::string & unsigned int start, unsigned int end, std::ostream &output_stream) - : _path(std::move(images_path)), _images(), _preprocessor(std::move(preprocessor)), _bgr(bgr), _offset(0), _output_stream(output_stream) + : _path(std::move(images_path)), + _images(), + _preprocessor(std::move(preprocessor)), + _bgr(bgr), + _offset(0), + _output_stream(output_stream) { ARM_COMPUTE_EXIT_ON_MSG(start > end, "Invalid validation range!"); @@ -322,10 +336,10 @@ ValidationInputAccessor::ValidationInputAccessor(const std::string & // Parse image names unsigned int counter = 0; - for(std::string line; !std::getline(ifs, line).fail() && counter <= end; ++counter) + for (std::string line; !std::getline(ifs, line).fail() && counter <= end; ++counter) { // Add image to process if withing range - if(counter >= start) + if (counter >= start) { std::stringstream linestream(line); std::string image_name; @@ -335,7 +349,7 @@ ValidationInputAccessor::ValidationInputAccessor(const std::string & } } } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", image_list.c_str(), e.what()); } @@ -344,7 +358,7 @@ ValidationInputAccessor::ValidationInputAccessor(const std::string & bool ValidationInputAccessor::access_tensor(arm_compute::ITensor &tensor) { bool ret = _offset < _images.size(); - if(ret) + if (ret) { utils::JPEGLoader jpeg; @@ -356,28 +370,30 @@ bool ValidationInputAccessor::access_tensor(arm_compute::ITensor &tensor) // Get permutated shape and permutation parameters TensorShape permuted_shape = tensor.info()->tensor_shape(); arm_compute::PermutationVector perm; - if(tensor.info()->data_layout() != DataLayout::NCHW) + if (tensor.info()->data_layout() != DataLayout::NCHW) { - std::tie(permuted_shape, perm) = compute_permutation_parameters(tensor.info()->tensor_shape(), - tensor.info()->data_layout()); + std::tie(permuted_shape, perm) = + compute_permutation_parameters(tensor.info()->tensor_shape(), tensor.info()->data_layout()); } #ifdef __arm__ ARM_COMPUTE_EXIT_ON_MSG_VAR(jpeg.width() != permuted_shape.x() || jpeg.height() != permuted_shape.y(), - "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu32 ",%" PRIu32 "].", + "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu32 + ",%" PRIu32 "].", jpeg.width(), jpeg.height(), permuted_shape.x(), permuted_shape.y()); #else // __arm__ ARM_COMPUTE_EXIT_ON_MSG_VAR(jpeg.width() != permuted_shape.x() || jpeg.height() != permuted_shape.y(), - "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu64 ",%" PRIu64 "].", - jpeg.width(), jpeg.height(), - static_cast(permuted_shape.x()), static_cast(permuted_shape.y())); + "Failed to load image file: dimensions [%d,%d] not correct, expected [%" PRIu64 + ",%" PRIu64 "].", + jpeg.width(), jpeg.height(), static_cast(permuted_shape.x()), + static_cast(permuted_shape.y())); #endif // __arm__ // Fill the tensor with the JPEG content (BGR) jpeg.fill_planar_tensor(tensor, _bgr); // Preprocess tensor - if(_preprocessor) + if (_preprocessor) { _preprocessor->preprocess(tensor); } @@ -402,10 +418,10 @@ ValidationOutputAccessor::ValidationOutputAccessor(const std::string &image_list // Parse image correctly classified labels unsigned int counter = 0; - for(std::string line; !std::getline(ifs, line).fail() && counter <= end; ++counter) + for (std::string line; !std::getline(ifs, line).fail() && counter <= end; ++counter) { // Add label if within range - if(counter >= start) + if (counter >= start) { std::stringstream linestream(line); std::string image_name; @@ -416,7 +432,7 @@ ValidationOutputAccessor::ValidationOutputAccessor(const std::string &image_list } } } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", image_list.c_str(), e.what()); } @@ -432,11 +448,11 @@ void ValidationOutputAccessor::reset() bool ValidationOutputAccessor::access_tensor(arm_compute::ITensor &tensor) { bool ret = _offset < _results.size(); - if(ret) + if (ret) { // Get results std::vector tensor_results; - switch(tensor.info()->data_type()) + switch (tensor.info()->data_type()) { case DataType::QASYMM8: tensor_results = access_predictions_tensor(tensor); @@ -459,7 +475,7 @@ bool ValidationOutputAccessor::access_tensor(arm_compute::ITensor &tensor) } // Report top_n accuracy - if(_offset >= _results.size()) + if (_offset >= _results.size()) { report_top_n(1, _results.size(), _positive_samples_top1); report_top_n(5, _results.size(), _positive_samples_top5); @@ -481,23 +497,19 @@ std::vector ValidationOutputAccessor::access_predictions_tensor(arm_comp // Sort results std::iota(std::begin(index), std::end(index), static_cast(0)); - std::sort(std::begin(index), std::end(index), - [&](size_t a, size_t b) - { - return output_net[a] > output_net[b]; - }); + std::sort(std::begin(index), std::end(index), [&](size_t a, size_t b) { return output_net[a] > output_net[b]; }); return index; } -void ValidationOutputAccessor::aggregate_sample(const std::vector &res, size_t &positive_samples, size_t top_n, size_t correct_label) +void ValidationOutputAccessor::aggregate_sample(const std::vector &res, + size_t &positive_samples, + size_t top_n, + size_t correct_label) { - auto is_valid_label = [correct_label](size_t label) - { - return label == correct_label; - }; + auto is_valid_label = [correct_label](size_t label) { return label == correct_label; }; - if(std::any_of(std::begin(res), std::begin(res) + top_n, is_valid_label)) + if (std::any_of(std::begin(res), std::begin(res) + top_n, is_valid_label)) { ++positive_samples; } @@ -508,14 +520,15 @@ void ValidationOutputAccessor::report_top_n(size_t top_n, size_t total_samples, size_t negative_samples = total_samples - positive_samples; float accuracy = positive_samples / static_cast(total_samples); - _output_stream << "----------Top " << top_n << " accuracy ----------" << std::endl - << std::endl; + _output_stream << "----------Top " << top_n << " accuracy ----------" << std::endl << std::endl; _output_stream << "Positive samples : " << positive_samples << std::endl; _output_stream << "Negative samples : " << negative_samples << std::endl; _output_stream << "Accuracy : " << accuracy << std::endl; } -DetectionOutputAccessor::DetectionOutputAccessor(const std::string &labels_path, std::vector &imgs_tensor_shapes, std::ostream &output_stream) +DetectionOutputAccessor::DetectionOutputAccessor(const std::string &labels_path, + std::vector &imgs_tensor_shapes, + std::ostream &output_stream) : _labels(), _tensor_shapes(std::move(imgs_tensor_shapes)), _output_stream(output_stream) { _labels.clear(); @@ -527,12 +540,12 @@ DetectionOutputAccessor::DetectionOutputAccessor(const std::string &labels_path, ifs.exceptions(std::ifstream::badbit); ifs.open(labels_path, std::ios::in | std::ios::binary); - for(std::string line; !std::getline(ifs, line).fail();) + for (std::string line; !std::getline(ifs, line).fail();) { _labels.emplace_back(line); } } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", labels_path.c_str(), e.what()); } @@ -542,26 +555,24 @@ template void DetectionOutputAccessor::access_predictions_tensor(ITensor &tensor) { const size_t num_detection = tensor.info()->valid_region().shape.y(); - const auto output_prt = reinterpret_cast(tensor.buffer() + tensor.info()->offset_first_element_in_bytes()); + const auto output_prt = reinterpret_cast(tensor.buffer() + tensor.info()->offset_first_element_in_bytes()); - if(num_detection > 0) + if (num_detection > 0) { - _output_stream << "---------------------- Detections ----------------------" << std::endl - << std::endl; + _output_stream << "---------------------- Detections ----------------------" << std::endl << std::endl; - _output_stream << std::left << std::setprecision(4) << std::setw(8) << "Image | " << std::setw(8) << "Label | " << std::setw(12) << "Confidence | " + _output_stream << std::left << std::setprecision(4) << std::setw(8) << "Image | " << std::setw(8) << "Label | " + << std::setw(12) << "Confidence | " << "[ xmin, ymin, xmax, ymax ]" << std::endl; - for(size_t i = 0; i < num_detection; ++i) + for (size_t i = 0; i < num_detection; ++i) { auto im = static_cast(output_prt[i * 7]); - _output_stream << std::setw(8) << im << std::setw(8) - << _labels[output_prt[i * 7 + 1]] << std::setw(12) << output_prt[i * 7 + 2] - << " [" << (output_prt[i * 7 + 3] * _tensor_shapes[im].x()) - << ", " << (output_prt[i * 7 + 4] * _tensor_shapes[im].y()) - << ", " << (output_prt[i * 7 + 5] * _tensor_shapes[im].x()) - << ", " << (output_prt[i * 7 + 6] * _tensor_shapes[im].y()) - << "]" << std::endl; + _output_stream << std::setw(8) << im << std::setw(8) << _labels[output_prt[i * 7 + 1]] << std::setw(12) + << output_prt[i * 7 + 2] << " [" << (output_prt[i * 7 + 3] * _tensor_shapes[im].x()) << ", " + << (output_prt[i * 7 + 4] * _tensor_shapes[im].y()) << ", " + << (output_prt[i * 7 + 5] * _tensor_shapes[im].x()) << ", " + << (output_prt[i * 7 + 6] * _tensor_shapes[im].y()) << "]" << std::endl; } } else @@ -574,7 +585,7 @@ bool DetectionOutputAccessor::access_tensor(ITensor &tensor) { ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&tensor, 1, DataType::F32); - switch(tensor.info()->data_type()) + switch (tensor.info()->data_type()) { case DataType::F32: access_predictions_tensor(tensor); @@ -586,7 +597,9 @@ bool DetectionOutputAccessor::access_tensor(ITensor &tensor) return false; } -TopNPredictionsAccessor::TopNPredictionsAccessor(const std::string &labels_path, size_t top_n, std::ostream &output_stream) +TopNPredictionsAccessor::TopNPredictionsAccessor(const std::string &labels_path, + size_t top_n, + std::ostream &output_stream) : _labels(), _output_stream(output_stream), _top_n(top_n) { _labels.clear(); @@ -598,12 +611,12 @@ TopNPredictionsAccessor::TopNPredictionsAccessor(const std::string &labels_path, ifs.exceptions(std::ifstream::badbit); ifs.open(labels_path, std::ios::in | std::ios::binary); - for(std::string line; !std::getline(ifs, line).fail();) + for (std::string line; !std::getline(ifs, line).fail();) { _labels.emplace_back(line); } } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", labels_path.c_str(), e.what()); } @@ -627,18 +640,13 @@ void TopNPredictionsAccessor::access_predictions_tensor(ITensor &tensor) // Sort results std::iota(std::begin(index), std::end(index), static_cast(0)); std::sort(std::begin(index), std::end(index), - [&](size_t a, size_t b) - { - return classes_prob[a] > classes_prob[b]; - }); + [&](size_t a, size_t b) { return classes_prob[a] > classes_prob[b]; }); - _output_stream << "---------- Top " << _top_n << " predictions ----------" << std::endl - << std::endl; - for(size_t i = 0; i < _top_n; ++i) + _output_stream << "---------- Top " << _top_n << " predictions ----------" << std::endl << std::endl; + for (size_t i = 0; i < _top_n; ++i) { - _output_stream << std::fixed << std::setprecision(4) - << +classes_prob[index.at(i)] - << " - [id = " << index.at(i) << "]" + _output_stream << std::fixed << std::setprecision(4) << +classes_prob[index.at(i)] << " - [id = " << index.at(i) + << "]" << ", " << _labels[index.at(i)] << std::endl; } } @@ -648,7 +656,7 @@ bool TopNPredictionsAccessor::access_tensor(ITensor &tensor) ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&tensor, 1, DataType::F32, DataType::QASYMM8); ARM_COMPUTE_ERROR_ON(_labels.size() != tensor.info()->dimension(0)); - switch(tensor.info()->data_type()) + switch (tensor.info()->data_type()) { case DataType::QASYMM8: access_predictions_tensor(tensor); @@ -673,9 +681,9 @@ void RandomAccessor::fill(ITensor &tensor, D &&distribution) { std::mt19937 gen(_seed); - if(tensor.info()->padding().empty() && (dynamic_cast(&tensor) == nullptr)) + if (tensor.info()->padding().empty() && (dynamic_cast(&tensor) == nullptr)) { - for(size_t offset = 0; offset < tensor.info()->total_size(); offset += tensor.info()->element_size()) + for (size_t offset = 0; offset < tensor.info()->total_size(); offset += tensor.info()->element_size()) { const auto value = static_cast(distribution(gen)); *reinterpret_cast(tensor.buffer() + offset) = value; @@ -687,17 +695,18 @@ void RandomAccessor::fill(ITensor &tensor, D &&distribution) Window window; window.use_tensor_dimensions(tensor.info()->tensor_shape()); - execute_window_loop(window, [&](const Coordinates & id) - { - const auto value = static_cast(distribution(gen)); - *reinterpret_cast(tensor.ptr_to_element(id)) = value; - }); + execute_window_loop(window, + [&](const Coordinates &id) + { + const auto value = static_cast(distribution(gen)); + *reinterpret_cast(tensor.ptr_to_element(id)) = value; + }); } } bool RandomAccessor::access_tensor(ITensor &tensor) { - switch(tensor.info()->data_type()) + switch (tensor.info()->data_type()) { case DataType::QASYMM8: case DataType::U8: @@ -750,7 +759,8 @@ bool RandomAccessor::access_tensor(ITensor &tensor) } case DataType::F16: { - arm_compute::utils::uniform_real_distribution_16bit distribution_f16(_lower.get(), _upper.get()); + arm_compute::utils::uniform_real_distribution_16bit distribution_f16(_lower.get(), + _upper.get()); fill(tensor, distribution_f16); break; } @@ -779,7 +789,7 @@ NumPyBinLoader::NumPyBinLoader(std::string filename, DataLayout file_layout) bool NumPyBinLoader::access_tensor(ITensor &tensor) { - if(!_already_loaded) + if (!_already_loaded) { utils::NPYLoader loader; loader.open(_filename, _file_layout); diff --git a/utils/GraphUtils.h b/utils/GraphUtils.h index 80055acc0f..b48300bd01 100644 --- a/utils/GraphUtils.h +++ b/utils/GraphUtils.h @@ -66,7 +66,7 @@ public: * @param[in] bgr Boolean specifying if the preprocessing should assume BGR format * @param[in] scale Scale value */ - CaffePreproccessor(std::array mean = std::array { { 0, 0, 0 } }, bool bgr = true, float scale = 1.f); + CaffePreproccessor(std::array mean = std::array{{0, 0, 0}}, bool bgr = true, float scale = 1.f); void preprocess(ITensor &tensor) override; private: @@ -74,8 +74,8 @@ private: void preprocess_typed(ITensor &tensor); std::array _mean; - bool _bgr; - float _scale; + bool _bgr; + float _scale; }; /** TF preproccessor */ @@ -155,7 +155,11 @@ public: * @param[in] data_layout (Optional) DataLayout of the numpy tensor data. * @param[out] output_stream (Optional) Output stream */ - NumPyAccessor(std::string npy_path, TensorShape shape, DataType data_type, DataLayout data_layout = DataLayout::NCHW, std::ostream &output_stream = std::cout); + NumPyAccessor(std::string npy_path, + TensorShape shape, + DataType data_type, + DataLayout data_layout = DataLayout::NCHW, + std::ostream &output_stream = std::cout); /** Allow instances of this class to be move constructed */ NumPyAccessor(NumPyAccessor &&) = default; /** Prevent instances of this class from being copied (As this class contains pointers) */ @@ -353,7 +357,9 @@ public: * @param[in] imgs_tensor_shapes Network input images tensor shapes. * @param[out] output_stream (Optional) Output stream */ - DetectionOutputAccessor(const std::string &labels_path, std::vector &imgs_tensor_shapes, std::ostream &output_stream = std::cout); + DetectionOutputAccessor(const std::string &labels_path, + std::vector &imgs_tensor_shapes, + std::ostream &output_stream = std::cout); /** Allow instances of this class to be move constructed */ DetectionOutputAccessor(DetectionOutputAccessor &&) = default; /** Prevent instances of this class from being copied (As this class contains pointers) */ @@ -422,7 +428,7 @@ public: private: template - void fill(ITensor &tensor, D &&distribution); + void fill(ITensor &tensor, D &&distribution); PixelValue _lower; PixelValue _upper; std::random_device::result_type _seed; @@ -458,7 +464,8 @@ private: * * @return A ramdom accessor */ -inline std::unique_ptr get_random_accessor(PixelValue lower, PixelValue upper, const std::random_device::result_type seed = 0) +inline std::unique_ptr +get_random_accessor(PixelValue lower, PixelValue upper, const std::random_device::result_type seed = 0) { return std::make_unique(lower, upper, seed); } @@ -473,11 +480,10 @@ inline std::unique_ptr get_random_accessor(PixelValue lo * * @return An appropriate tensor accessor */ -inline std::unique_ptr get_weights_accessor(const std::string &path, - const std::string &data_file, - DataLayout file_layout = DataLayout::NCHW) +inline std::unique_ptr +get_weights_accessor(const std::string &path, const std::string &data_file, DataLayout file_layout = DataLayout::NCHW) { - if(path.empty()) + if (path.empty()) { return std::make_unique(); } @@ -495,30 +501,28 @@ inline std::unique_ptr get_weights_accessor(const std::s * * @return An appropriate tensor accessor */ -inline std::unique_ptr get_input_accessor(const arm_compute::utils::CommonGraphParams &graph_parameters, - std::unique_ptr preprocessor = nullptr, - bool bgr = true) +inline std::unique_ptr +get_input_accessor(const arm_compute::utils::CommonGraphParams &graph_parameters, + std::unique_ptr preprocessor = nullptr, + bool bgr = true) { - if(!graph_parameters.validation_file.empty()) + if (!graph_parameters.validation_file.empty()) { - return std::make_unique(graph_parameters.validation_file, - graph_parameters.validation_path, - std::move(preprocessor), - bgr, - graph_parameters.validation_range_start, - graph_parameters.validation_range_end); + return std::make_unique( + graph_parameters.validation_file, graph_parameters.validation_path, std::move(preprocessor), bgr, + graph_parameters.validation_range_start, graph_parameters.validation_range_end); } else { const std::string &image_file = graph_parameters.image; const std::string &image_file_lower = lower_string(image_file); - if(arm_compute::utility::endswith(image_file_lower, ".npy")) + if (arm_compute::utility::endswith(image_file_lower, ".npy")) { return std::make_unique(image_file, graph_parameters.data_layout); } - else if(arm_compute::utility::endswith(image_file_lower, ".jpeg") - || arm_compute::utility::endswith(image_file_lower, ".jpg") - || arm_compute::utility::endswith(image_file_lower, ".ppm")) + else if (arm_compute::utility::endswith(image_file_lower, ".jpeg") || + arm_compute::utility::endswith(image_file_lower, ".jpg") || + arm_compute::utility::endswith(image_file_lower, ".ppm")) { return std::make_unique(image_file, bgr, std::move(preprocessor)); } @@ -541,20 +545,20 @@ inline std::unique_ptr get_input_accessor(const arm_comp * * @return An appropriate tensor accessor */ -inline std::unique_ptr get_output_accessor(const arm_compute::utils::CommonGraphParams &graph_parameters, - size_t top_n = 5, - bool is_validation = false, - std::ostream &output_stream = std::cout) +inline std::unique_ptr +get_output_accessor(const arm_compute::utils::CommonGraphParams &graph_parameters, + size_t top_n = 5, + bool is_validation = false, + std::ostream &output_stream = std::cout) { ARM_COMPUTE_UNUSED(is_validation); - if(!graph_parameters.validation_file.empty()) + if (!graph_parameters.validation_file.empty()) { - return std::make_unique(graph_parameters.validation_file, - output_stream, + return std::make_unique(graph_parameters.validation_file, output_stream, graph_parameters.validation_range_start, graph_parameters.validation_range_end); } - else if(graph_parameters.labels.empty()) + else if (graph_parameters.labels.empty()) { return std::make_unique(0); } @@ -575,20 +579,20 @@ inline std::unique_ptr get_output_accessor(const arm_com * * @return An appropriate tensor accessor */ -inline std::unique_ptr get_detection_output_accessor(const arm_compute::utils::CommonGraphParams &graph_parameters, - std::vector tensor_shapes, - bool is_validation = false, - std::ostream &output_stream = std::cout) +inline std::unique_ptr +get_detection_output_accessor(const arm_compute::utils::CommonGraphParams &graph_parameters, + std::vector tensor_shapes, + bool is_validation = false, + std::ostream &output_stream = std::cout) { ARM_COMPUTE_UNUSED(is_validation); - if(!graph_parameters.validation_file.empty()) + if (!graph_parameters.validation_file.empty()) { - return std::make_unique(graph_parameters.validation_file, - output_stream, + return std::make_unique(graph_parameters.validation_file, output_stream, graph_parameters.validation_range_start, graph_parameters.validation_range_end); } - else if(graph_parameters.labels.empty()) + else if (graph_parameters.labels.empty()) { return std::make_unique(0); } @@ -609,10 +613,13 @@ inline std::unique_ptr get_detection_output_accessor(con * * @return An appropriate tensor accessor */ -inline std::unique_ptr get_npy_output_accessor(const std::string &npy_path, TensorShape shape, DataType data_type, DataLayout data_layout = DataLayout::NCHW, +inline std::unique_ptr get_npy_output_accessor(const std::string &npy_path, + TensorShape shape, + DataType data_type, + DataLayout data_layout = DataLayout::NCHW, std::ostream &output_stream = std::cout) { - if(npy_path.empty()) + if (npy_path.empty()) { return std::make_unique(0); } @@ -631,9 +638,10 @@ inline std::unique_ptr get_npy_output_accessor(const std * * @return An appropriate tensor accessor */ -inline std::unique_ptr get_save_npy_output_accessor(const std::string &npy_name, const bool is_fortran = false) +inline std::unique_ptr get_save_npy_output_accessor(const std::string &npy_name, + const bool is_fortran = false) { - if(npy_name.empty()) + if (npy_name.empty()) { return std::make_unique(0); } @@ -664,9 +672,11 @@ inline std::unique_ptr get_print_output_accessor(std::os */ inline TensorShape permute_shape(TensorShape tensor_shape, DataLayout in_data_layout, DataLayout out_data_layout) { - if(in_data_layout != out_data_layout) + if (in_data_layout != out_data_layout) { - arm_compute::PermutationVector perm_vec = (in_data_layout == DataLayout::NCHW) ? arm_compute::PermutationVector(2U, 0U, 1U) : arm_compute::PermutationVector(1U, 2U, 0U); + arm_compute::PermutationVector perm_vec = (in_data_layout == DataLayout::NCHW) + ? arm_compute::PermutationVector(2U, 0U, 1U) + : arm_compute::PermutationVector(1U, 2U, 0U); arm_compute::permute(tensor_shape, perm_vec); } return tensor_shape; @@ -681,7 +691,7 @@ inline TensorShape permute_shape(TensorShape tensor_shape, DataLayout in_data_la inline graph::Target set_target_hint(int target) { ARM_COMPUTE_ERROR_ON_MSG(target > 2, "Invalid target. Target must be 0 (NEON), 1 (OpenCL), 2 (OpenCL + Tuner)"); - if((target == 1 || target == 2)) + if ((target == 1 || target == 2)) { return graph::Target::CL; } diff --git a/utils/ImageLoader.h b/utils/ImageLoader.h index aab0f5e770..2ae1a416e2 100644 --- a/utils/ImageLoader.h +++ b/utils/ImageLoader.h @@ -68,8 +68,7 @@ public: * * @param[in] fs Image file stream */ - FileImageFeeder(std::ifstream &fs) - : _fs(fs) + FileImageFeeder(std::ifstream &fs) : _fs(fs) { } // Inherited overridden methods @@ -94,8 +93,7 @@ public: * * @param[in] data Pointer to data */ - MemoryImageFeeder(const uint8_t *data) - : _data(data) + MemoryImageFeeder(const uint8_t *data) : _data(data) { } /** Prevent instances of this class from being copied (As this class contains pointers) */ @@ -127,8 +125,7 @@ class IImageLoader { public: /** Default Constructor */ - IImageLoader() - : _feeder(nullptr), _width(0), _height(0) + IImageLoader() : _feeder(nullptr), _width(0), _height(0) { } /** Virtual base destructor */ @@ -188,7 +185,7 @@ public: // Validate feeding data validate_info(image.info()); - switch(image.info()->format()) + switch (image.info()->format()) { case Format::U8: { @@ -204,15 +201,17 @@ public: unsigned char green = 0; unsigned char blue = 0; - execute_window_loop(window, [&](const Coordinates &) - { - red = _feeder->get(); - green = _feeder->get(); - blue = _feeder->get(); + execute_window_loop( + window, + [&](const Coordinates &) + { + red = _feeder->get(); + green = _feeder->get(); + blue = _feeder->get(); - *out.ptr() = 0.2126f * red + 0.7152f * green + 0.0722f * blue; - }, - out); + *out.ptr() = 0.2126f * red + 0.7152f * green + 0.0722f * blue; + }, + out); break; } @@ -226,11 +225,8 @@ public: Iterator out(&image, window); size_t row_size = _width * image.info()->element_size(); - execute_window_loop(window, [&](const Coordinates &) - { - _feeder->get_row(out.ptr(), row_size); - }, - out); + execute_window_loop( + window, [&](const Coordinates &) { _feeder->get_row(out.ptr(), row_size); }, out); break; } @@ -241,7 +237,7 @@ public: // Unmap buffer if creating a CLTensor unmap(image); } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Loading image file: %s", e.what()); } @@ -257,15 +253,19 @@ public: void fill_planar_tensor(T &tensor, bool bgr = false) { ARM_COMPUTE_ERROR_ON(!is_open()); - ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&tensor, 1, DataType::U8, DataType::QASYMM8, DataType::F32, DataType::F16); + ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&tensor, 1, DataType::U8, DataType::QASYMM8, DataType::F32, + DataType::F16); const DataLayout data_layout = tensor.info()->data_layout(); const TensorShape tensor_shape = tensor.info()->tensor_shape(); ARM_COMPUTE_UNUSED(tensor_shape); - ARM_COMPUTE_ERROR_ON(tensor_shape[get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH)] != _width); - ARM_COMPUTE_ERROR_ON(tensor_shape[get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT)] != _height); - ARM_COMPUTE_ERROR_ON(tensor_shape[get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL)] != 3); + ARM_COMPUTE_ERROR_ON(tensor_shape[get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH)] != + _width); + ARM_COMPUTE_ERROR_ON(tensor_shape[get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT)] != + _height); + ARM_COMPUTE_ERROR_ON(tensor_shape[get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL)] != + 3); ARM_COMPUTE_ERROR_ON(_feeder.get() == nullptr); @@ -282,7 +282,7 @@ public: // Iterate through every pixel of the image Window window; - if(data_layout == DataLayout::NCHW) + if (data_layout == DataLayout::NCHW) { window.set(Window::DimX, Window::Dimension(0, _width, 1)); window.set(Window::DimY, Window::Dimension(0, _height, 1)); @@ -303,48 +303,50 @@ public: unsigned char green = 0; unsigned char blue = 0; - execute_window_loop(window, [&](const Coordinates &) - { - red = _feeder->get(); - green = _feeder->get(); - blue = _feeder->get(); - - switch(tensor.info()->data_type()) + execute_window_loop( + window, + [&](const Coordinates &) { - case DataType::U8: - case DataType::QASYMM8: - { - *(out.ptr() + 0 * stride_z) = bgr ? blue : red; - *(out.ptr() + 1 * stride_z) = green; - *(out.ptr() + 2 * stride_z) = bgr ? red : blue; - break; - } - case DataType::F32: - { - *reinterpret_cast(out.ptr() + 0 * stride_z) = static_cast(bgr ? blue : red); - *reinterpret_cast(out.ptr() + 1 * stride_z) = static_cast(green); - *reinterpret_cast(out.ptr() + 2 * stride_z) = static_cast(bgr ? red : blue); - break; - } - case DataType::F16: - { - *reinterpret_cast(out.ptr() + 0 * stride_z) = static_cast(bgr ? blue : red); - *reinterpret_cast(out.ptr() + 1 * stride_z) = static_cast(green); - *reinterpret_cast(out.ptr() + 2 * stride_z) = static_cast(bgr ? red : blue); - break; - } - default: + red = _feeder->get(); + green = _feeder->get(); + blue = _feeder->get(); + + switch (tensor.info()->data_type()) { - ARM_COMPUTE_ERROR("Unsupported data type"); + case DataType::U8: + case DataType::QASYMM8: + { + *(out.ptr() + 0 * stride_z) = bgr ? blue : red; + *(out.ptr() + 1 * stride_z) = green; + *(out.ptr() + 2 * stride_z) = bgr ? red : blue; + break; + } + case DataType::F32: + { + *reinterpret_cast(out.ptr() + 0 * stride_z) = static_cast(bgr ? blue : red); + *reinterpret_cast(out.ptr() + 1 * stride_z) = static_cast(green); + *reinterpret_cast(out.ptr() + 2 * stride_z) = static_cast(bgr ? red : blue); + break; + } + case DataType::F16: + { + *reinterpret_cast(out.ptr() + 0 * stride_z) = static_cast(bgr ? blue : red); + *reinterpret_cast(out.ptr() + 1 * stride_z) = static_cast(green); + *reinterpret_cast(out.ptr() + 2 * stride_z) = static_cast(bgr ? red : blue); + break; + } + default: + { + ARM_COMPUTE_ERROR("Unsupported data type"); + } } - } - }, - out); + }, + out); // Unmap buffer if creating a CLTensor unmap(tensor); } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Loading image file: %s", e.what()); } @@ -368,8 +370,7 @@ class PPMLoader : public IImageLoader { public: /** Default Constructor */ - PPMLoader() - : IImageLoader(), _fs() + PPMLoader() : IImageLoader(), _fs() { } @@ -386,7 +387,7 @@ public: _fs.exceptions(std::ifstream::failbit | std::ifstream::badbit); _fs.open(filename, std::ios::in | std::ios::binary); - unsigned int max_val = 0; + unsigned int max_val = 0; std::tie(_width, _height, max_val) = parse_ppm_header(_fs); ARM_COMPUTE_ERROR_ON_MSG_VAR(max_val >= 256, "2 bytes per colour channel not supported in file %s", @@ -394,14 +395,14 @@ public: _feeder = std::make_unique(_fs); } - catch(std::runtime_error &e) + catch (std::runtime_error &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", filename.c_str(), e.what()); } } void close() override { - if(is_open()) + if (is_open()) { _fs.close(); _feeder = nullptr; @@ -443,8 +444,7 @@ private: public: /** Default Constructor */ - JPEGLoader() - : IImageLoader(), _is_loaded(false), _data(nullptr) + JPEGLoader() : IImageLoader(), _is_loaded(false), _data(nullptr) { } @@ -457,7 +457,7 @@ public: { int bpp, width, height; uint8_t *rgb_image = stbi_load(filename.c_str(), &width, &height, &bpp, 3); - if(rgb_image == NULL) + if (rgb_image == NULL) { ARM_COMPUTE_ERROR_VAR("Accessing %s failed", filename.c_str()); } @@ -472,7 +472,7 @@ public: } void close() override { - if(is_open()) + if (is_open()) { _width = 0; _height = 0; @@ -483,7 +483,7 @@ public: /** Explicitly Releases the memory of the loaded data */ void release() { - if(_is_loaded) + if (_is_loaded) { _data.reset(); _is_loaded = false; @@ -492,7 +492,7 @@ public: } private: - bool _is_loaded; + bool _is_loaded; std::unique_ptr _data; }; @@ -509,7 +509,7 @@ public: static std::unique_ptr create(const std::string &filename) { ImageType type = arm_compute::utils::get_image_type_from_file(filename); - switch(type) + switch (type) { case ImageType::PPM: return std::make_unique(); diff --git a/utils/TypePrinter.h b/utils/TypePrinter.h index 69cc3d4fc0..4f14d985af 100644 --- a/utils/TypePrinter.h +++ b/utils/TypePrinter.h @@ -51,11 +51,13 @@ #include "arm_compute/function_info/MatMulInfo.h" #include "arm_compute/runtime/CL/CLTunerTypes.h" #include "arm_compute/runtime/CL/CLTypes.h" +#include "arm_compute/runtime/common/LSTMParams.h" #include "arm_compute/runtime/FunctionDescriptors.h" #include "arm_compute/runtime/NEON/functions/NEMatMul.h" -#include "arm_compute/runtime/common/LSTMParams.h" + #include "support/Cast.h" #include "support/StringSupport.h" + #include #include #include @@ -71,7 +73,7 @@ namespace arm_compute template std::string to_string_if_not_null(T *arg) { - if(arg == nullptr) + if (arg == nullptr) { return "nullptr"; } @@ -111,13 +113,13 @@ template os << "["; bool first = true; size_t i; - for(i = 0; i < args.size(); ++i) + for (i = 0; i < args.size(); ++i) { - if(i == max_print_size) + if (i == max_print_size) { break; } - if(first) + if (first) { first = false; } @@ -127,7 +129,7 @@ template } os << to_string(args[i]); } - if(i < args.size()) + if (i < args.size()) { os << ", ..."; } @@ -159,11 +161,11 @@ std::string to_string(const std::vector &args) template inline ::std::ostream &operator<<(::std::ostream &os, const Dimensions &dimensions) { - if(dimensions.num_dimensions() > 0) + if (dimensions.num_dimensions() > 0) { os << dimensions[0]; - for(unsigned int d = 1; d < dimensions.num_dimensions(); ++d) + for (unsigned int d = 1; d < dimensions.num_dimensions(); ++d) { os << "," << dimensions[d]; } @@ -181,7 +183,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const Dimensions &dimen */ inline ::std::ostream &operator<<(::std::ostream &os, const RoundingPolicy &rounding_policy) { - switch(rounding_policy) + switch (rounding_policy) { case RoundingPolicy::TO_ZERO: os << "TO_ZERO"; @@ -209,7 +211,8 @@ inline ::std::ostream &operator<<(::std::ostream &os, const RoundingPolicy &roun inline ::std::ostream &operator<<(::std::ostream &os, const WeightsInfo &weights_info) { os << weights_info.are_reshaped() << ";"; - os << weights_info.num_kernels() << ";" << weights_info.kernel_size().first << "," << weights_info.kernel_size().second; + os << weights_info.num_kernels() << ";" << weights_info.kernel_size().first << "," + << weights_info.kernel_size().second; return os; } @@ -273,7 +276,8 @@ inline ::std::ostream &operator<<(::std::ostream &os, const GEMMKernelInfo &gemm */ inline ::std::ostream &operator<<(::std::ostream &os, const GEMMLHSMatrixInfo &gemm_info) { - os << "( m0=" << (unsigned int)gemm_info.m0 << " k0=" << gemm_info.k0 << " v0=" << gemm_info.v0 << " trans=" << gemm_info.transpose << " inter=" << gemm_info.interleave << "})"; + os << "( m0=" << (unsigned int)gemm_info.m0 << " k0=" << gemm_info.k0 << " v0=" << gemm_info.v0 + << " trans=" << gemm_info.transpose << " inter=" << gemm_info.interleave << "})"; return os; } @@ -286,8 +290,9 @@ inline ::std::ostream &operator<<(::std::ostream &os, const GEMMLHSMatrixInfo &g */ inline ::std::ostream &operator<<(::std::ostream &os, const GEMMRHSMatrixInfo &gemm_info) { - os << "( n0=" << (unsigned int)gemm_info.n0 << " k0=" << gemm_info.k0 << " h0=" << gemm_info.h0 << " trans=" << gemm_info.transpose << " inter=" << gemm_info.interleave << " exp_img=" << - gemm_info.export_to_cl_image << "})"; + os << "( n0=" << (unsigned int)gemm_info.n0 << " k0=" << gemm_info.k0 << " h0=" << gemm_info.h0 + << " trans=" << gemm_info.transpose << " inter=" << gemm_info.interleave + << " exp_img=" << gemm_info.export_to_cl_image << "})"; return os; } @@ -340,8 +345,8 @@ inline std::string to_string(const GEMMKernelInfo &gemm_info) inline ::std::ostream &operator<<(::std::ostream &os, const BoundingBoxTransformInfo &bbox_info) { auto weights = bbox_info.weights(); - os << "(" << bbox_info.img_width() << "x" << bbox_info.img_height() << ")~" << bbox_info.scale() << "(weights={" << weights[0] << ", " << weights[1] << ", " << weights[2] << ", " << weights[3] << - "})"; + os << "(" << bbox_info.img_width() << "x" << bbox_info.img_height() << ")~" << bbox_info.scale() << "(weights={" + << weights[0] << ", " << weights[1] << ", " << weights[2] << ", " << weights[3] << "})"; return os; } @@ -454,7 +459,7 @@ inline std::string to_string(const QuantizationInfo &quantization_info) */ inline ::std::ostream &operator<<(::std::ostream &os, const ActivationLayerInfo::ActivationFunction &act_function) { - switch(act_function) + switch (act_function) { case ActivationLayerInfo::ActivationFunction::ABS: os << "ABS"; @@ -521,7 +526,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const ActivationLayerInfo: inline std::string to_string(const arm_compute::ActivationLayerInfo &info) { std::stringstream str; - if(info.enabled()) + if (info.enabled()) { str << info.activation(); } @@ -537,9 +542,9 @@ inline std::string to_string(const arm_compute::ActivationLayerInfo &info) */ inline ::std::ostream &operator<<(::std::ostream &os, const ActivationLayerInfo *info) { - if(info != nullptr) + if (info != nullptr) { - if(info->enabled()) + if (info->enabled()) { os << info->activation(); os << "("; @@ -581,7 +586,7 @@ inline std::string to_string(const arm_compute::ActivationLayerInfo::ActivationF */ inline ::std::ostream &operator<<(::std::ostream &os, const NormType &norm_type) { - switch(norm_type) + switch (norm_type) { case NormType::CROSS_MAP: os << "CROSS_MAP"; @@ -634,7 +639,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const NormalizationLayerIn */ inline ::std::ostream &operator<<(::std::ostream &os, const PoolingType &pool_type) { - switch(pool_type) + switch (pool_type) { case PoolingType::AVG: os << "AVG"; @@ -689,7 +694,7 @@ inline std::string to_string(const RoundingPolicy &rounding_policy) */ inline ::std::ostream &operator<<(::std::ostream &os, const DataLayout &data_layout) { - switch(data_layout) + switch (data_layout) { case DataLayout::UNKNOWN: os << "UNKNOWN"; @@ -736,7 +741,7 @@ inline std::string to_string(const arm_compute::DataLayout &data_layout) */ inline ::std::ostream &operator<<(::std::ostream &os, const DataLayoutDimension &data_layout_dim) { - switch(data_layout_dim) + switch (data_layout_dim) { case DataLayoutDimension::WIDTH: os << "WIDTH"; @@ -768,7 +773,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const DataLayoutDimension */ inline ::std::ostream &operator<<(::std::ostream &os, const DataType &data_type) { - switch(data_type) + switch (data_type) { case DataType::UNKNOWN: os << "UNKNOWN"; @@ -859,7 +864,7 @@ inline std::string to_string(const arm_compute::DataType &data_type) */ inline ::std::ostream &operator<<(::std::ostream &os, const Format &format) { - switch(format) + switch (format) { case Format::UNKNOWN: os << "UNKNOWN"; @@ -941,7 +946,7 @@ inline std::string to_string(const Format &format) */ inline ::std::ostream &operator<<(::std::ostream &os, const Channel &channel) { - switch(channel) + switch (channel) { case Channel::UNKNOWN: os << "UNKNOWN"; @@ -1008,7 +1013,7 @@ inline std::string to_string(const Channel &channel) */ inline ::std::ostream &operator<<(::std::ostream &os, const BorderMode &mode) { - switch(mode) + switch (mode) { case BorderMode::UNDEFINED: os << "UNDEFINED"; @@ -1035,10 +1040,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const BorderMode &mode) */ inline ::std::ostream &operator<<(::std::ostream &os, const BorderSize &border) { - os << border.top << "," - << border.right << "," - << border.bottom << "," - << border.left; + os << border.top << "," << border.right << "," << border.bottom << "," << border.left; return os; } @@ -1053,7 +1055,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const BorderSize &border) inline ::std::ostream &operator<<(::std::ostream &os, const PaddingList &padding) { os << "{"; - for(auto const &p : padding) + for (auto const &p : padding) { os << "{" << p.first << "," << p.second << "}"; } @@ -1071,7 +1073,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const PaddingList &padding inline ::std::ostream &operator<<(::std::ostream &os, const Multiples &multiples) { os << "("; - for(size_t i = 0; i < multiples.size() - 1; i++) + for (size_t i = 0; i < multiples.size() - 1; i++) { os << multiples[i] << ", "; } @@ -1088,7 +1090,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const Multiples &multiples */ inline ::std::ostream &operator<<(::std::ostream &os, const InterpolationPolicy &policy) { - switch(policy) + switch (policy) { case InterpolationPolicy::NEAREST_NEIGHBOR: os << "NEAREST_NEIGHBOR"; @@ -1115,7 +1117,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const InterpolationPolicy */ inline ::std::ostream &operator<<(::std::ostream &os, const SamplingPolicy &policy) { - switch(policy) + switch (policy) { case SamplingPolicy::CENTER: os << "CENTER"; @@ -1146,18 +1148,16 @@ inline ::std::ostream &operator<<(std::ostream &os, const ITensorInfo *info) << "DataLayout=" << string_from_data_layout(data_layout) << "," << "DataType=" << string_from_data_type(data_type); - if(is_data_type_quantized(data_type)) + if (is_data_type_quantized(data_type)) { const QuantizationInfo qinfo = info->quantization_info(); const auto scales = qinfo.scale(); const auto offsets = qinfo.offset(); os << ", QuantizationInfo={" - << "scales.size=" << scales.size() - << ", scale(s)=" << scales << ", "; + << "scales.size=" << scales.size() << ", scale(s)=" << scales << ", "; - os << "offsets.size=" << offsets.size() - << ", offset(s)=" << offsets << "}"; + os << "offsets.size=" << offsets.size() << ", offset(s)=" << offsets << "}"; } return os; } @@ -1210,7 +1210,7 @@ inline std::string to_string(const ITensorInfo &info) inline std::string to_string(const ITensorInfo *info) { std::string ret_str = "nullptr"; - if(info != nullptr) + if (info != nullptr) { std::stringstream str; str << info; @@ -1239,7 +1239,7 @@ inline std::string to_string(ITensorInfo *info) inline std::string to_string(const ITensor *tensor) { std::string ret_str = "nullptr"; - if(tensor != nullptr) + if (tensor != nullptr) { std::stringstream str; str << "ITensor->info(): " << tensor->info(); @@ -1282,7 +1282,7 @@ inline std::string to_string(ITensor &tensor) inline std::string to_string(const ICLTensor *cl_tensor) { std::string ret_str = "nullptr"; - if(cl_tensor != nullptr) + if (cl_tensor != nullptr) { std::stringstream str; str << "ICLTensor->info(): " << cl_tensor->info(); @@ -1311,11 +1311,7 @@ inline std::string to_string(ICLTensor *cl_tensor) */ inline ::std::ostream &operator<<(::std::ostream &os, const cl::NDRange &nd_range) { - os << "{" - << nd_range[0] << "," - << nd_range[1] << "," - << nd_range[2] - << "}"; + os << "{" << nd_range[0] << "," << nd_range[1] << "," << nd_range[2] << "}"; return os; } @@ -1451,9 +1447,9 @@ inline ::std::ostream &operator<<(::std::ostream &os, const Window::Dimension &d inline ::std::ostream &operator<<(::std::ostream &os, const Window &win) { os << "{"; - for(unsigned int i = 0; i < Coordinates::num_max_dimensions; i++) + for (unsigned int i = 0; i < Coordinates::num_max_dimensions; i++) { - if(i > 0) + if (i > 0) { os << ", "; } @@ -1537,7 +1533,7 @@ inline std::string to_string(const Window &win) inline std::string to_string(Window *win) { std::string ret_str = "nullptr"; - if(win != nullptr) + if (win != nullptr) { std::stringstream str; str << *win; @@ -1570,7 +1566,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const Rectangle &rect) */ inline ::std::ostream &operator<<(::std::ostream &os, const PaddingMode &mode) { - switch(mode) + switch (mode) { case PaddingMode::CONSTANT: os << "CONSTANT"; @@ -1612,8 +1608,8 @@ inline ::std::ostream &operator<<(::std::ostream &os, const PadStrideInfo &pad_s { os << pad_stride_info.stride().first << "," << pad_stride_info.stride().second; os << ";"; - os << pad_stride_info.pad_left() << "," << pad_stride_info.pad_right() << "," - << pad_stride_info.pad_top() << "," << pad_stride_info.pad_bottom(); + os << pad_stride_info.pad_left() << "," << pad_stride_info.pad_right() << "," << pad_stride_info.pad_top() << "," + << pad_stride_info.pad_bottom(); return os; } @@ -1718,7 +1714,7 @@ inline std::string to_string(const SamplingPolicy &policy) */ inline ::std::ostream &operator<<(::std::ostream &os, const ConvertPolicy &policy) { - switch(policy) + switch (policy) { case ConvertPolicy::WRAP: os << "WRAP"; @@ -1749,7 +1745,7 @@ inline std::string to_string(const ConvertPolicy &policy) */ inline ::std::ostream &operator<<(::std::ostream &os, const ArithmeticOperation &op) { - switch(op) + switch (op) { case ArithmeticOperation::ADD: os << "ADD"; @@ -1804,7 +1800,7 @@ inline std::string to_string(const ArithmeticOperation &op) */ inline ::std::ostream &operator<<(::std::ostream &os, const ReductionOperation &op) { - switch(op) + switch (op) { case ReductionOperation::SUM: os << "SUM"; @@ -1859,7 +1855,7 @@ inline std::string to_string(const ReductionOperation &op) */ inline ::std::ostream &operator<<(::std::ostream &os, const ComparisonOperation &op) { - switch(op) + switch (op) { case ComparisonOperation::Equal: os << "Equal"; @@ -1895,7 +1891,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const ComparisonOperation */ inline ::std::ostream &operator<<(::std::ostream &os, const ElementWiseUnary &op) { - switch(op) + switch (op) { case ElementWiseUnary::RSQRT: os << "RSQRT"; @@ -1992,7 +1988,7 @@ inline std::string to_string(const PoolingLayerInfo &info) str << "{Type=" << info.pool_type << "," << "DataLayout=" << info.data_layout << "," << "IsGlobalPooling=" << info.is_global_pooling; - if(!info.is_global_pooling) + if (!info.is_global_pooling) { str << "," << "PoolSize=" << info.pool_size.width << "," << info.pool_size.height << "," @@ -2038,8 +2034,7 @@ inline std::string to_string(const Size3D &type) */ inline ::std::ostream &operator<<(::std::ostream &os, const Padding3D &padding3d) { - os << padding3d.left << "," << padding3d.right << "," - << padding3d.top << "," << padding3d.bottom << "," + os << padding3d.left << "," << padding3d.right << "," << padding3d.top << "," << padding3d.bottom << "," << padding3d.front << "," << padding3d.back; return os; } @@ -2066,7 +2061,7 @@ inline std::string to_string(const Padding3D &padding3d) */ inline ::std::ostream &operator<<(::std::ostream &os, const DimensionRoundingType &rounding_type) { - switch(rounding_type) + switch (rounding_type) { case DimensionRoundingType::CEIL: os << "CEIL"; @@ -2091,7 +2086,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const Pooling3dLayerInfo & { os << "{Type=" << info.pool_type << "," << "IsGlobalPooling=" << info.is_global_pooling; - if(!info.is_global_pooling) + if (!info.is_global_pooling) { os << "," << "PoolSize=" << info.pool_size << ", " @@ -2128,16 +2123,10 @@ inline std::string to_string(const PriorBoxLayerInfo &info) { std::stringstream str; str << "{"; - str << "Clip:" << info.clip() - << "Flip:" << info.flip() - << "StepX:" << info.steps()[0] - << "StepY:" << info.steps()[1] - << "MinSizes:" << info.min_sizes().size() - << "MaxSizes:" << info.max_sizes().size() - << "ImgSizeX:" << info.img_size().x - << "ImgSizeY:" << info.img_size().y - << "Offset:" << info.offset() - << "Variances:" << info.variances().size(); + str << "Clip:" << info.clip() << "Flip:" << info.flip() << "StepX:" << info.steps()[0] + << "StepY:" << info.steps()[1] << "MinSizes:" << info.min_sizes().size() + << "MaxSizes:" << info.max_sizes().size() << "ImgSizeX:" << info.img_size().x + << "ImgSizeY:" << info.img_size().y << "Offset:" << info.offset() << "Variances:" << info.variances().size(); str << "}"; return str.str(); } @@ -2178,7 +2167,7 @@ inline std::string to_string(const Size2D &type) */ inline ::std::ostream &operator<<(::std::ostream &os, const ConvolutionMethod &conv_method) { - switch(conv_method) + switch (conv_method) { case ConvolutionMethod::GEMM: os << "GEMM"; @@ -2224,7 +2213,7 @@ inline std::string to_string(const ConvolutionMethod &conv_method) */ inline ::std::ostream &operator<<(::std::ostream &os, const GPUTarget &gpu_target) { - switch(gpu_target) + switch (gpu_target) { case GPUTarget::GPU_ARCH_MASK: os << "GPU_ARCH_MASK"; @@ -2358,7 +2347,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const DetectionWindow &det */ inline ::std::ostream &operator<<(::std::ostream &os, const DetectionOutputLayerCodeType &detection_code) { - switch(detection_code) + switch (detection_code) { case DetectionOutputLayerCodeType::CENTER_SIZE: os << "CENTER_SIZE"; @@ -2410,8 +2399,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const DetectionOutputLayer << "BackgroundLabelId=" << detection_info.background_label_id() << "," << "ConfidenceThreshold=" << detection_info.confidence_threshold() << "," << "TopK=" << detection_info.top_k() << "," - << "NumLocClasses=" << detection_info.num_loc_classes() - << "}"; + << "NumLocClasses=" << detection_info.num_loc_classes() << "}"; return os; } @@ -2447,8 +2435,7 @@ inline ::std::ostream &operator<<(::std::ostream &os, const DetectionPostProcess << "ScaleValue_h=" << detection_info.scale_value_h() << "," << "ScaleValue_w=" << detection_info.scale_value_w() << "," << "UseRegularNms=" << detection_info.use_regular_nms() << "," - << "DetectionPerClass=" << detection_info.detection_per_class() - << "}"; + << "DetectionPerClass=" << detection_info.detection_per_class() << "}"; return os; } @@ -2488,16 +2475,9 @@ inline std::string to_string(const DetectionWindow &detection_window) */ inline ::std::ostream &operator<<(::std::ostream &os, const PriorBoxLayerInfo &info) { - os << "Clip:" << info.clip() - << "Flip:" << info.flip() - << "StepX:" << info.steps()[0] - << "StepY:" << info.steps()[1] - << "MinSizes:" << info.min_sizes() - << "MaxSizes:" << info.max_sizes() - << "ImgSizeX:" << info.img_size().x - << "ImgSizeY:" << info.img_size().y - << "Offset:" << info.offset() - << "Variances:" << info.variances(); + os << "Clip:" << info.clip() << "Flip:" << info.flip() << "StepX:" << info.steps()[0] << "StepY:" << info.steps()[1] + << "MinSizes:" << info.min_sizes() << "MaxSizes:" << info.max_sizes() << "ImgSizeX:" << info.img_size().x + << "ImgSizeY:" << info.img_size().y << "Offset:" << info.offset() << "Variances:" << info.variances(); return os; } @@ -2528,7 +2508,7 @@ inline std::string to_string(const WinogradInfo &type) */ inline std::string to_string(const CLTunerMode val) { - switch(val) + switch (val) { case CLTunerMode::EXHAUSTIVE: { @@ -2557,7 +2537,7 @@ inline std::string to_string(const CLTunerMode val) */ inline std::string to_string(CLGEMMKernelType val) { - switch(val) + switch (val) { case CLGEMMKernelType::NATIVE: { @@ -2660,7 +2640,7 @@ inline std::string to_string(const FullyConnectedLayerInfo &info) */ inline ::std::ostream &operator<<(::std::ostream &os, const GEMMLowpOutputStageType &gemm_type) { - switch(gemm_type) + switch (gemm_type) { case GEMMLowpOutputStageType::NONE: os << "NONE"; @@ -2827,7 +2807,7 @@ inline std::string to_string(const ScaleKernelInfo &scale_info) */ inline ::std::ostream &operator<<(::std::ostream &os, const FFTDirection &fft_dir) { - switch(fft_dir) + switch (fft_dir) { case FFTDirection::Forward: os << "Forward"; @@ -2945,7 +2925,7 @@ inline std::string to_string(const Coordinates2D &coord_2d) */ inline ::std::ostream &operator<<(::std::ostream &os, const FuseBatchNormalizationType &fuse_type) { - switch(fuse_type) + switch (fuse_type) { case FuseBatchNormalizationType::CONVOLUTION: os << "CONVOLUTION"; @@ -3073,7 +3053,7 @@ inline std::string to_string(const uint8_t num) */ inline ::std::ostream &operator<<(::std::ostream &os, const NMSType &nms_type) { - switch(nms_type) + switch (nms_type) { case NMSType::LINEAR: os << "LINEAR"; @@ -3196,46 +3176,46 @@ inline std::string to_string(const Conv3dInfo &conv3d_info) inline std::string to_string(const WeightFormat wf) { #define __CASE_WEIGHT_FORMAT(wf) \ -case WeightFormat::wf: \ - return #wf; - switch(wf) + case WeightFormat::wf: \ + return #wf; + switch (wf) { - __CASE_WEIGHT_FORMAT(UNSPECIFIED) - __CASE_WEIGHT_FORMAT(ANY) - __CASE_WEIGHT_FORMAT(OHWI) - __CASE_WEIGHT_FORMAT(OHWIo2) - __CASE_WEIGHT_FORMAT(OHWIo4) - __CASE_WEIGHT_FORMAT(OHWIo8) - __CASE_WEIGHT_FORMAT(OHWIo16) - __CASE_WEIGHT_FORMAT(OHWIo32) - __CASE_WEIGHT_FORMAT(OHWIo64) - __CASE_WEIGHT_FORMAT(OHWIo128) - __CASE_WEIGHT_FORMAT(OHWIo4i2) - __CASE_WEIGHT_FORMAT(OHWIo4i2_bf16) - __CASE_WEIGHT_FORMAT(OHWIo8i2) - __CASE_WEIGHT_FORMAT(OHWIo8i2_bf16) - __CASE_WEIGHT_FORMAT(OHWIo16i2) - __CASE_WEIGHT_FORMAT(OHWIo16i2_bf16) - __CASE_WEIGHT_FORMAT(OHWIo32i2) - __CASE_WEIGHT_FORMAT(OHWIo32i2_bf16) - __CASE_WEIGHT_FORMAT(OHWIo64i2) - __CASE_WEIGHT_FORMAT(OHWIo64i2_bf16) - __CASE_WEIGHT_FORMAT(OHWIo4i4) - __CASE_WEIGHT_FORMAT(OHWIo4i4_bf16) - __CASE_WEIGHT_FORMAT(OHWIo8i4) - __CASE_WEIGHT_FORMAT(OHWIo8i4_bf16) - __CASE_WEIGHT_FORMAT(OHWIo16i4) - __CASE_WEIGHT_FORMAT(OHWIo16i4_bf16) - __CASE_WEIGHT_FORMAT(OHWIo32i4) - __CASE_WEIGHT_FORMAT(OHWIo32i4_bf16) - __CASE_WEIGHT_FORMAT(OHWIo64i4) - __CASE_WEIGHT_FORMAT(OHWIo64i4_bf16) - __CASE_WEIGHT_FORMAT(OHWIo2i8) - __CASE_WEIGHT_FORMAT(OHWIo4i8) - __CASE_WEIGHT_FORMAT(OHWIo8i8) - __CASE_WEIGHT_FORMAT(OHWIo16i8) - __CASE_WEIGHT_FORMAT(OHWIo32i8) - __CASE_WEIGHT_FORMAT(OHWIo64i8) + __CASE_WEIGHT_FORMAT(UNSPECIFIED) + __CASE_WEIGHT_FORMAT(ANY) + __CASE_WEIGHT_FORMAT(OHWI) + __CASE_WEIGHT_FORMAT(OHWIo2) + __CASE_WEIGHT_FORMAT(OHWIo4) + __CASE_WEIGHT_FORMAT(OHWIo8) + __CASE_WEIGHT_FORMAT(OHWIo16) + __CASE_WEIGHT_FORMAT(OHWIo32) + __CASE_WEIGHT_FORMAT(OHWIo64) + __CASE_WEIGHT_FORMAT(OHWIo128) + __CASE_WEIGHT_FORMAT(OHWIo4i2) + __CASE_WEIGHT_FORMAT(OHWIo4i2_bf16) + __CASE_WEIGHT_FORMAT(OHWIo8i2) + __CASE_WEIGHT_FORMAT(OHWIo8i2_bf16) + __CASE_WEIGHT_FORMAT(OHWIo16i2) + __CASE_WEIGHT_FORMAT(OHWIo16i2_bf16) + __CASE_WEIGHT_FORMAT(OHWIo32i2) + __CASE_WEIGHT_FORMAT(OHWIo32i2_bf16) + __CASE_WEIGHT_FORMAT(OHWIo64i2) + __CASE_WEIGHT_FORMAT(OHWIo64i2_bf16) + __CASE_WEIGHT_FORMAT(OHWIo4i4) + __CASE_WEIGHT_FORMAT(OHWIo4i4_bf16) + __CASE_WEIGHT_FORMAT(OHWIo8i4) + __CASE_WEIGHT_FORMAT(OHWIo8i4_bf16) + __CASE_WEIGHT_FORMAT(OHWIo16i4) + __CASE_WEIGHT_FORMAT(OHWIo16i4_bf16) + __CASE_WEIGHT_FORMAT(OHWIo32i4) + __CASE_WEIGHT_FORMAT(OHWIo32i4_bf16) + __CASE_WEIGHT_FORMAT(OHWIo64i4) + __CASE_WEIGHT_FORMAT(OHWIo64i4_bf16) + __CASE_WEIGHT_FORMAT(OHWIo2i8) + __CASE_WEIGHT_FORMAT(OHWIo4i8) + __CASE_WEIGHT_FORMAT(OHWIo8i8) + __CASE_WEIGHT_FORMAT(OHWIo16i8) + __CASE_WEIGHT_FORMAT(OHWIo32i8) + __CASE_WEIGHT_FORMAT(OHWIo64i8) default: return "invalid value"; } @@ -3282,8 +3262,7 @@ inline std::string to_string(const std::tuple::max(), '\n'); } @@ -71,11 +71,11 @@ void discard_comments(std::ifstream &fs) */ void discard_comments_and_spaces(std::ifstream &fs) { - while(true) + while (true) { discard_comments(fs); - if(isspace(fs.peek()) == 0) + if (isspace(fs.peek()) == 0) { break; } @@ -88,13 +88,12 @@ void discard_comments_and_spaces(std::ifstream &fs) #ifndef BENCHMARK_EXAMPLES int run_example(int argc, char **argv, std::unique_ptr example) { - std::cout << "\n" - << argv[0] << "\n\n"; + std::cout << "\n" << argv[0] << "\n\n"; try { bool status = example->do_setup(argc, argv); - if(!status) + if (!status) { return 1; } @@ -105,19 +104,17 @@ int run_example(int argc, char **argv, std::unique_ptr example) return 0; } #ifdef ARM_COMPUTE_CL - catch(cl::Error &err) + catch (cl::Error &err) { std::cerr << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; - std::cerr << std::endl - << "ERROR " << err.what() << "(" << err.err() << ")" << std::endl; + std::cerr << std::endl << "ERROR " << err.what() << "(" << err.err() << ")" << std::endl; std::cerr << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; } #endif /* ARM_COMPUTE_CL */ - catch(std::runtime_error &err) + catch (std::runtime_error &err) { std::cerr << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; - std::cerr << std::endl - << "ERROR " << err.what() << " " << (errno ? strerror(errno) : "") << std::endl; + std::cerr << std::endl << "ERROR " << err.what() << " " << (errno ? strerror(errno) : "") << std::endl; std::cerr << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; } @@ -131,13 +128,15 @@ void draw_detection_rectangle(ITensor *tensor, const DetectionWindow &rect, uint { ARM_COMPUTE_ERROR_ON_FORMAT_NOT_IN(tensor, Format::RGB888); - uint8_t *top = tensor->info()->offset_element_in_bytes(Coordinates(rect.x, rect.y)) + tensor->buffer(); - uint8_t *bottom = tensor->info()->offset_element_in_bytes(Coordinates(rect.x, rect.y + rect.height)) + tensor->buffer(); - uint8_t *left = top; - uint8_t *right = tensor->info()->offset_element_in_bytes(Coordinates(rect.x + rect.width, rect.y)) + tensor->buffer(); - size_t stride = tensor->info()->strides_in_bytes()[Window::DimY]; + uint8_t *top = tensor->info()->offset_element_in_bytes(Coordinates(rect.x, rect.y)) + tensor->buffer(); + uint8_t *bottom = + tensor->info()->offset_element_in_bytes(Coordinates(rect.x, rect.y + rect.height)) + tensor->buffer(); + uint8_t *left = top; + uint8_t *right = + tensor->info()->offset_element_in_bytes(Coordinates(rect.x + rect.width, rect.y)) + tensor->buffer(); + size_t stride = tensor->info()->strides_in_bytes()[Window::DimY]; - for(size_t x = 0; x < rect.width; ++x) + for (size_t x = 0; x < rect.width; ++x) { top[0] = r; top[1] = g; @@ -150,7 +149,7 @@ void draw_detection_rectangle(ITensor *tensor, const DetectionWindow &rect, uint bottom += 3; } - for(size_t y = 0; y < rect.height; ++y) + for (size_t y = 0; y < rect.height; ++y) { left[0] = r; left[1] = g; @@ -176,22 +175,22 @@ ImageType get_image_type_from_file(const std::string &filename) fs.open(filename, std::ios::in | std::ios::binary); // Identify type from magic number - std::array magic_number{ { 0 } }; + std::array magic_number{{0}}; fs >> magic_number[0] >> magic_number[1]; // PPM check - if(static_cast(magic_number[0]) == 'P' && static_cast(magic_number[1]) == '6') + if (static_cast(magic_number[0]) == 'P' && static_cast(magic_number[1]) == '6') { type = ImageType::PPM; } - else if(magic_number[0] == 0xFF && magic_number[1] == 0xD8) + else if (magic_number[0] == 0xFF && magic_number[1] == 0xD8) { type = ImageType::JPEG; } fs.close(); } - catch(std::runtime_error &e) + catch (std::runtime_error &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", filename.c_str(), e.what()); } @@ -202,7 +201,7 @@ ImageType get_image_type_from_file(const std::string &filename) std::tuple parse_ppm_header(std::ifstream &fs) { // Check the PPM magic number is valid - std::array magic_number{ { 0 } }; + std::array magic_number{{0}}; fs >> magic_number[0] >> magic_number[1]; ARM_COMPUTE_ERROR_ON_MSG(magic_number[0] != 'P' || magic_number[1] != '6', "Invalid file type"); ARM_COMPUTE_UNUSED(magic_number); @@ -238,12 +237,12 @@ npy::header_t parse_npy_header(std::ifstream &fs) //NOLINT // Parse header npy::header_t header = npy::parse_header(header_s); - bool fortran_order = false; - std::vector shape = header.shape; + bool fortran_order = false; + std::vector shape = header.shape; std::reverse(shape.begin(), shape.end()); - return npy::header_t{ header.dtype, fortran_order, shape }; + return npy::header_t{header.dtype, fortran_order, shape}; } /** This function returns the amount of memory free reading from /proc/meminfo @@ -255,15 +254,15 @@ uint64_t get_mem_free_from_meminfo() std::string line_attribute; std::ifstream file_meminfo("/proc/meminfo"); - if(file_meminfo.is_open()) + if (file_meminfo.is_open()) { - while(!(file_meminfo >> line_attribute).fail()) + while (!(file_meminfo >> line_attribute).fail()) { //Test if is the line containing MemFree - if(line_attribute == "MemFree:") + if (line_attribute == "MemFree:") { uint64_t mem_available; - if(!(file_meminfo >> mem_available).fail()) + if (!(file_meminfo >> mem_available).fail()) { return mem_available; } diff --git a/utils/Utils.h b/utils/Utils.h index d181022ffe..626cbcf07f 100644 --- a/utils/Utils.h +++ b/utils/Utils.h @@ -87,9 +87,9 @@ public: return true; }; /** Run the example. */ - virtual void do_run() {}; + virtual void do_run(){}; /** Teardown the example. */ - virtual void do_teardown() {}; + virtual void do_teardown(){}; /** Default destructor. */ virtual ~Example() = default; @@ -117,7 +117,8 @@ int run_example(int argc, char **argv) * @param[in] g Green colour to use * @param[in] b Blue colour to use */ -void draw_detection_rectangle(arm_compute::ITensor *tensor, const arm_compute::DetectionWindow &rect, uint8_t r, uint8_t g, uint8_t b); +void draw_detection_rectangle( + arm_compute::ITensor *tensor, const arm_compute::DetectionWindow &rect, uint8_t r, uint8_t g, uint8_t b); /** Gets image type given a file * @@ -157,7 +158,7 @@ inline std::string get_typestring(DataType data_type) const unsigned int i = 1; const char *c = reinterpret_cast(&i); std::string endianness; - if(*c == 1) + if (*c == 1) { endianness = std::string("<"); } @@ -167,7 +168,7 @@ inline std::string get_typestring(DataType data_type) } const std::string no_endianness("|"); - switch(data_type) + switch (data_type) { case DataType::U8: case DataType::QASYMM8: @@ -253,7 +254,8 @@ inline void unmap(CLTensor &tensor) template class uniform_real_distribution_16bit { - static_assert(std::is_same::value || std::is_same::value, "Only half and bfloat16 data types supported"); + static_assert(std::is_same::value || std::is_same::value, + "Only half and bfloat16 data types supported"); public: using result_type = T; @@ -262,8 +264,7 @@ public: * @param[in] min Minimum value of the distribution * @param[in] max Maximum value of the distribution */ - explicit uniform_real_distribution_16bit(float min = 0.f, float max = 1.0) - : dist(min, max) + explicit uniform_real_distribution_16bit(float min = 0.f, float max = 1.0) : dist(min, max) { } @@ -285,8 +286,7 @@ class NPYLoader { public: /** Default constructor */ - NPYLoader() - : _fs(), _shape(), _fortran_order(false), _typestring(), _file_layout(DataLayout::NCHW) + NPYLoader() : _fs(), _shape(), _fortran_order(false), _typestring(), _file_layout(DataLayout::NCHW) { } @@ -310,7 +310,7 @@ public: _fortran_order = header.fortran_order; _typestring = header.dtype.str(); } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Accessing %s: %s", npy_filename.c_str(), e.what()); } @@ -341,10 +341,10 @@ public: // Use the size of the input NPY tensor TensorShape shape; shape.set_num_dimensions(_shape.size()); - for(size_t i = 0; i < _shape.size(); ++i) + for (size_t i = 0; i < _shape.size(); ++i) { size_t src = i; - if(_fortran_order) + if (_fortran_order) { src = _shape.size() - 1 - i; } @@ -365,7 +365,8 @@ public: void fill_tensor(T &tensor) { ARM_COMPUTE_ERROR_ON(!is_open()); - ARM_COMPUTE_ERROR_ON_DATA_TYPE_NOT_IN(&tensor, arm_compute::DataType::QASYMM8, arm_compute::DataType::S32, arm_compute::DataType::F32, arm_compute::DataType::F16); + ARM_COMPUTE_ERROR_ON_DATA_TYPE_NOT_IN(&tensor, arm_compute::DataType::QASYMM8, arm_compute::DataType::S32, + arm_compute::DataType::F32, arm_compute::DataType::F16); try { // Map buffer if creating a CLTensor @@ -377,7 +378,8 @@ public: const size_t end_position = _fs.tellg(); _fs.seekg(current_position, std::ios_base::beg); - ARM_COMPUTE_ERROR_ON_MSG((end_position - current_position) < tensor.info()->tensor_shape().total_size() * tensor.info()->element_size(), + ARM_COMPUTE_ERROR_ON_MSG((end_position - current_position) < + tensor.info()->tensor_shape().total_size() * tensor.info()->element_size(), "Not enough data in file"); ARM_COMPUTE_UNUSED(end_position); @@ -385,12 +387,12 @@ public: std::string expect_typestr = get_typestring(tensor.info()->data_type()); bool enable_f32_to_f16_conversion = false; - if(_typestring != expect_typestr) + if (_typestring != expect_typestr) { const std::string f32_typestring = "data_layout()); // Correct dimensions (Needs to match TensorShape dimension corrections) - if(_shape.size() != tensor.info()->tensor_shape().num_dimensions()) + if (_shape.size() != tensor.info()->tensor_shape().num_dimensions()) { - for(int i = static_cast(_shape.size()) - 1; i > 0; --i) + for (int i = static_cast(_shape.size()) - 1; i > 0; --i) { - if(_shape[i] == 1) + if (_shape[i] == 1) { _shape.pop_back(); } @@ -419,22 +421,28 @@ public: TensorShape permuted_shape = tensor.info()->tensor_shape(); arm_compute::PermutationVector perm; - if(are_layouts_different && tensor.info()->tensor_shape().num_dimensions() > 2) + if (are_layouts_different && tensor.info()->tensor_shape().num_dimensions() > 2) { - perm = (tensor.info()->data_layout() == arm_compute::DataLayout::NHWC) ? arm_compute::PermutationVector(2U, 0U, 1U) : arm_compute::PermutationVector(1U, 2U, 0U); - arm_compute::PermutationVector perm_vec = (tensor.info()->data_layout() == arm_compute::DataLayout::NCHW) ? arm_compute::PermutationVector(2U, 0U, 1U) : arm_compute::PermutationVector(1U, 2U, 0U); + perm = (tensor.info()->data_layout() == arm_compute::DataLayout::NHWC) + ? arm_compute::PermutationVector(2U, 0U, 1U) + : arm_compute::PermutationVector(1U, 2U, 0U); + arm_compute::PermutationVector perm_vec = + (tensor.info()->data_layout() == arm_compute::DataLayout::NCHW) + ? arm_compute::PermutationVector(2U, 0U, 1U) + : arm_compute::PermutationVector(1U, 2U, 0U); arm_compute::permute(permuted_shape, perm_vec); } // Validate tensor shape - ARM_COMPUTE_ERROR_ON_MSG(_shape.size() != tensor.info()->tensor_shape().num_dimensions(), "Tensor ranks mismatch"); - for(size_t i = 0; i < _shape.size(); ++i) + ARM_COMPUTE_ERROR_ON_MSG(_shape.size() != tensor.info()->tensor_shape().num_dimensions(), + "Tensor ranks mismatch"); + for (size_t i = 0; i < _shape.size(); ++i) { ARM_COMPUTE_ERROR_ON_MSG(permuted_shape[i] != _shape[i], "Tensor dimensions mismatch"); } - switch(tensor.info()->data_type()) + switch (tensor.info()->data_type()) { case arm_compute::DataType::QASYMM8: case arm_compute::DataType::S32: @@ -442,7 +450,8 @@ public: case arm_compute::DataType::F16: { // Read data - if(!are_layouts_different && !_fortran_order && tensor.info()->padding().empty() && !enable_f32_to_f16_conversion) + if (!are_layouts_different && !_fortran_order && tensor.info()->padding().empty() && + !enable_f32_to_f16_conversion) { // If tensor has no padding read directly from stream. _fs.read(reinterpret_cast(tensor.buffer()), tensor.info()->total_size()); @@ -452,19 +461,19 @@ public: // If tensor has padding or is in fortran order accessing tensor elements through execution window. Window window; const unsigned int num_dims = _shape.size(); - if(_fortran_order) + if (_fortran_order) { - for(unsigned int dim = 0; dim < num_dims; dim++) + for (unsigned int dim = 0; dim < num_dims; dim++) { permuted_shape.set(dim, _shape[num_dims - dim - 1]); perm.set(dim, num_dims - dim - 1); } - if(are_layouts_different) + if (are_layouts_different) { // Permute only if num_dimensions greater than 2 - if(num_dims > 2) + if (num_dims > 2) { - if(_file_layout == DataLayout::NHWC) // i.e destination is NCHW --> permute(1,2,0) + if (_file_layout == DataLayout::NHWC) // i.e destination is NCHW --> permute(1,2,0) { arm_compute::permute(perm, arm_compute::PermutationVector(1U, 2U, 0U)); } @@ -477,22 +486,25 @@ public: } window.use_tensor_dimensions(permuted_shape); - execute_window_loop(window, [&](const Coordinates & id) - { - Coordinates dst(id); - arm_compute::permute(dst, perm); - if(enable_f32_to_f16_conversion) - { - float f32_val = 0; - _fs.read(reinterpret_cast(&f32_val), 4u); - half f16_val = half_float::half_cast(f32_val); - *(reinterpret_cast(tensor.ptr_to_element(dst))) = f16_val; - } - else - { - _fs.read(reinterpret_cast(tensor.ptr_to_element(dst)), tensor.info()->element_size()); - } - }); + execute_window_loop(window, + [&](const Coordinates &id) + { + Coordinates dst(id); + arm_compute::permute(dst, perm); + if (enable_f32_to_f16_conversion) + { + float f32_val = 0; + _fs.read(reinterpret_cast(&f32_val), 4u); + half f16_val = + half_float::half_cast(f32_val); + *(reinterpret_cast(tensor.ptr_to_element(dst))) = f16_val; + } + else + { + _fs.read(reinterpret_cast(tensor.ptr_to_element(dst)), + tensor.info()->element_size()); + } + }); } break; @@ -504,7 +516,7 @@ public: // Unmap buffer if creating a CLTensor unmap(tensor); } - catch(const std::ifstream::failure &e) + catch (const std::ifstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Loading NPY file: %s", e.what()); } @@ -543,13 +555,12 @@ void save_to_ppm(T &tensor, const std::string &ppm_filename) const unsigned int width = tensor.info()->tensor_shape()[0]; const unsigned int height = tensor.info()->tensor_shape()[1]; - fs << "P6\n" - << width << " " << height << " 255\n"; + fs << "P6\n" << width << " " << height << " 255\n"; // Map buffer if creating a CLTensor map(tensor, true); - switch(tensor.info()->format()) + switch (tensor.info()->format()) { case arm_compute::Format::U8: { @@ -559,13 +570,15 @@ void save_to_ppm(T &tensor, const std::string &ppm_filename) arm_compute::Iterator in(&tensor, window); - arm_compute::execute_window_loop(window, [&](const arm_compute::Coordinates &) - { - const unsigned char value = *in.ptr(); + arm_compute::execute_window_loop( + window, + [&](const arm_compute::Coordinates &) + { + const unsigned char value = *in.ptr(); - fs << value << value << value; - }, - in); + fs << value << value << value; + }, + in); break; } @@ -577,11 +590,13 @@ void save_to_ppm(T &tensor, const std::string &ppm_filename) arm_compute::Iterator in(&tensor, window); - arm_compute::execute_window_loop(window, [&](const arm_compute::Coordinates &) - { - fs.write(reinterpret_cast(in.ptr()), width * tensor.info()->element_size()); - }, - in); + arm_compute::execute_window_loop( + window, + [&](const arm_compute::Coordinates &) { + fs.write(reinterpret_cast(in.ptr()), + width * tensor.info()->element_size()); + }, + in); break; } @@ -592,7 +607,7 @@ void save_to_ppm(T &tensor, const std::string &ppm_filename) // Unmap buffer if creating a CLTensor unmap(tensor); } - catch(const std::ofstream::failure &e) + catch (const std::ofstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Writing %s: (%s)", ppm_filename.c_str(), e.what()); } @@ -620,7 +635,7 @@ void save_to_npy(T &tensor, const std::string &npy_filename, bool fortran_order) std::vector shape(tensor.info()->num_dimensions()); - for(unsigned int i = 0, j = tensor.info()->num_dimensions() - 1; i < tensor.info()->num_dimensions(); ++i, --j) + for (unsigned int i = 0, j = tensor.info()->num_dimensions() - 1; i < tensor.info()->num_dimensions(); ++i, --j) { shape[i] = tensor.info()->tensor_shape()[!fortran_order ? j : i]; } @@ -634,7 +649,7 @@ void save_to_npy(T &tensor, const std::string &npy_filename, bool fortran_order) const npy::dtype_t dtype = npy::dtype_map.at(std::type_index(typeid(tmp))); std::ofstream stream(npy_filename, std::ofstream::binary); - npy::header_t header{ dtype, fortran_order, shape }; + npy::header_t header{dtype, fortran_order, shape}; npy::write_header(stream, header); arm_compute::Window window; @@ -642,16 +657,16 @@ void save_to_npy(T &tensor, const std::string &npy_filename, bool fortran_order) arm_compute::Iterator in(&tensor, window); - arm_compute::execute_window_loop(window, [&](const arm_compute::Coordinates &) - { - stream.write(reinterpret_cast(in.ptr()), sizeof(typestring_type)); - }, - in); + arm_compute::execute_window_loop( + window, + [&](const arm_compute::Coordinates &) + { stream.write(reinterpret_cast(in.ptr()), sizeof(typestring_type)); }, + in); // Unmap buffer if creating a CLTensor unmap(tensor); } - catch(const std::ofstream::failure &e) + catch (const std::ofstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Writing %s: (%s)", npy_filename.c_str(), e.what()); } @@ -675,7 +690,7 @@ void load_trained_data(T &tensor, const std::string &filename) // Open file fs.open(filename, std::ios::in | std::ios::binary); - if(!fs.good()) + if (!fs.good()) { throw std::runtime_error("Could not load binary data: " + filename); } @@ -687,23 +702,26 @@ void load_trained_data(T &tensor, const std::string &filename) window.set(arm_compute::Window::DimX, arm_compute::Window::Dimension(0, 1, 1)); - for(unsigned int d = 1; d < tensor.info()->num_dimensions(); ++d) + for (unsigned int d = 1; d < tensor.info()->num_dimensions(); ++d) { window.set(d, Window::Dimension(0, tensor.info()->tensor_shape()[d], 1)); } arm_compute::Iterator in(&tensor, window); - execute_window_loop(window, [&](const Coordinates &) - { - fs.read(reinterpret_cast(in.ptr()), tensor.info()->tensor_shape()[0] * tensor.info()->element_size()); - }, - in); + execute_window_loop( + window, + [&](const Coordinates &) + { + fs.read(reinterpret_cast(in.ptr()), + tensor.info()->tensor_shape()[0] * tensor.info()->element_size()); + }, + in); // Unmap buffer if creating a CLTensor unmap(tensor); } - catch(const std::ofstream::failure &e) + catch (const std::ofstream::failure &e) { ARM_COMPUTE_ERROR_VAR("Writing %s: (%s)", filename.c_str(), e.what()); } @@ -718,11 +736,8 @@ void fill_tensor_value(TensorType &tensor, T value) window.use_tensor_dimensions(tensor.info()->tensor_shape()); Iterator it_tensor(&tensor, window); - execute_window_loop(window, [&](const Coordinates &) - { - *reinterpret_cast(it_tensor.ptr()) = value; - }, - it_tensor); + execute_window_loop( + window, [&](const Coordinates &) { *reinterpret_cast(it_tensor.ptr()) = value; }, it_tensor); unmap(tensor); } @@ -745,22 +760,23 @@ void fill_tensor_vector(TensorType &tensor, std::vector vec) int i = 0; Iterator it_tensor(&tensor, window); - execute_window_loop(window, [&](const Coordinates &) - { - *reinterpret_cast(it_tensor.ptr()) = vec.at(i++); - }, - it_tensor); + execute_window_loop( + window, [&](const Coordinates &) { *reinterpret_cast(it_tensor.ptr()) = vec.at(i++); }, it_tensor); unmap(tensor); } template -void fill_random_tensor(TensorType &tensor, std::random_device::result_type seed, T lower_bound = std::numeric_limits::lowest(), T upper_bound = std::numeric_limits::max()) +void fill_random_tensor(TensorType &tensor, + std::random_device::result_type seed, + T lower_bound = std::numeric_limits::lowest(), + T upper_bound = std::numeric_limits::max()) { constexpr bool is_fp_16bit = std::is_same::value || std::is_same::value; constexpr bool is_integral = std::is_integral::value && !is_fp_16bit; - using fp_dist_type = typename std::conditional, std::uniform_real_distribution>::type; + using fp_dist_type = typename std::conditional, + std::uniform_real_distribution>::type; using dist_type = typename std::conditional, fp_dist_type>::type; std::mt19937 gen(seed); @@ -772,17 +788,16 @@ void fill_random_tensor(TensorType &tensor, std::random_device::result_type seed window.use_tensor_dimensions(tensor.info()->tensor_shape()); Iterator it(&tensor, window); - execute_window_loop(window, [&](const Coordinates &) - { - *reinterpret_cast(it.ptr()) = dist(gen); - }, - it); + execute_window_loop( + window, [&](const Coordinates &) { *reinterpret_cast(it.ptr()) = dist(gen); }, it); unmap(tensor); } template -void fill_random_tensor(TensorType &tensor, T lower_bound = std::numeric_limits::lowest(), T upper_bound = std::numeric_limits::max()) +void fill_random_tensor(TensorType &tensor, + T lower_bound = std::numeric_limits::lowest(), + T upper_bound = std::numeric_limits::max()) { std::random_device rd; fill_random_tensor(tensor, rd(), lower_bound, upper_bound); @@ -791,7 +806,8 @@ void fill_random_tensor(TensorType &tensor, T lower_bound = std::numeric_limits< template void init_sgemm_output(T &dst, T &src0, T &src1, arm_compute::DataType dt) { - dst.allocator()->init(TensorInfo(TensorShape(src1.info()->dimension(0), src0.info()->dimension(1), src0.info()->dimension(2)), 1, dt)); + dst.allocator()->init(TensorInfo( + TensorShape(src1.info()->dimension(0), src0.info()->dimension(1), src0.info()->dimension(2)), 1, dt)); } /** This function returns the amount of memory free reading from /proc/meminfo * @@ -823,14 +839,16 @@ int compare_tensor(ITensor &tensor1, ITensor &tensor2, T tolerance) Iterator itensor1(&tensor1, window); Iterator itensor2(&tensor2, window); - execute_window_loop(window, [&](const Coordinates &) - { - if(std::abs(*reinterpret_cast(itensor1.ptr()) - *reinterpret_cast(itensor2.ptr())) > tolerance) + execute_window_loop( + window, + [&](const Coordinates &) { - ++num_mismatches; - } - }, - itensor1, itensor2); + if (std::abs(*reinterpret_cast(itensor1.ptr()) - *reinterpret_cast(itensor2.ptr())) > tolerance) + { + ++num_mismatches; + } + }, + itensor1, itensor2); unmap(itensor1); unmap(itensor2); diff --git a/utils/command_line/CommandLineParser.h b/utils/command_line/CommandLineParser.h index 523f25e8a1..57796bce73 100644 --- a/utils/command_line/CommandLineParser.h +++ b/utils/command_line/CommandLineParser.h @@ -24,14 +24,13 @@ #ifndef ARM_COMPUTE_UTILS_COMMANDLINEPARSER #define ARM_COMPUTE_UTILS_COMMANDLINEPARSER -#include "Option.h" #include "arm_compute/core/utils/misc/Utility.h" +#include "Option.h" #include #include #include #include -#include #include #include #include @@ -56,7 +55,7 @@ public: * @return Pointer to the option. The option is owned by the parser. */ template - T *add_option(const std::string &name, As &&... args); + T *add_option(const std::string &name, As &&...args); /** Function to add a new positional argument to the parser. * @@ -65,7 +64,7 @@ public: * @return Pointer to the option. The option is owned by the parser. */ template - T *add_positional_option(As &&... args); + T *add_positional_option(As &&...args); /** Parses the command line arguments and updates the options accordingly. * @@ -101,14 +100,14 @@ private: }; template -inline T *CommandLineParser::add_option(const std::string &name, As &&... args) +inline T *CommandLineParser::add_option(const std::string &name, As &&...args) { auto result = _options.emplace(name, std::make_unique(name, std::forward(args)...)); return static_cast(result.first->second.get()); } template -inline T *CommandLineParser::add_positional_option(As &&... args) +inline T *CommandLineParser::add_positional_option(As &&...args) { _positional_options.emplace_back(std::make_unique(std::forward(args)...)); return static_cast(_positional_options.back().get()); @@ -116,11 +115,11 @@ inline T *CommandLineParser::add_positional_option(As &&... args) inline void CommandLineParser::parse(int argc, char **argv) { - const std::regex option_regex{ "--((?:no-)?)([^=]+)(?:=(.*))?" }; + const std::regex option_regex{"--((?:no-)?)([^=]+)(?:=(.*))?"}; - const auto set_option = [&](const std::string & option, const std::string & name, const std::string & value) + const auto set_option = [&](const std::string &option, const std::string &name, const std::string &value) { - if(_options.find(name) == _options.end()) + if (_options.find(name) == _options.end()) { _unknown_options.push_back(option); return; @@ -128,7 +127,7 @@ inline void CommandLineParser::parse(int argc, char **argv) const bool success = _options[name]->parse(value); - if(!success) + if (!success) { _invalid_options.push_back(option); } @@ -136,26 +135,27 @@ inline void CommandLineParser::parse(int argc, char **argv) unsigned int positional_index = 0; - for(int i = 1; i < argc; ++i) + for (int i = 1; i < argc; ++i) { - std::string mixed_case_opt{ argv[i] }; + std::string mixed_case_opt{argv[i]}; int equal_sign = mixed_case_opt.find('='); int pos = (equal_sign == -1) ? strlen(argv[i]) : equal_sign; - const std::string option = arm_compute::utility::tolower(mixed_case_opt.substr(0, pos)) + mixed_case_opt.substr(pos); - std::smatch option_matches; + const std::string option = + arm_compute::utility::tolower(mixed_case_opt.substr(0, pos)) + mixed_case_opt.substr(pos); + std::smatch option_matches; - if(std::regex_match(option, option_matches, option_regex)) + if (std::regex_match(option, option_matches, option_regex)) { // Boolean option - if(option_matches.str(3).empty()) + if (option_matches.str(3).empty()) { set_option(option, option_matches.str(2), option_matches.str(1).empty() ? "true" : "false"); } else { // Can't have "no-" and a value - if(!option_matches.str(1).empty()) + if (!option_matches.str(1).empty()) { _invalid_options.emplace_back(option); } @@ -167,7 +167,7 @@ inline void CommandLineParser::parse(int argc, char **argv) } else { - if(positional_index >= _positional_options.size()) + if (positional_index >= _positional_options.size()) { _invalid_options.push_back(mixed_case_opt); } @@ -184,30 +184,30 @@ inline bool CommandLineParser::validate() const { bool is_valid = true; - for(const auto &option : _options) + for (const auto &option : _options) { - if(option.second->is_required() && !option.second->is_set()) + if (option.second->is_required() && !option.second->is_set()) { is_valid = false; std::cerr << "ERROR: Option '" << option.second->name() << "' is required but not given!\n"; } } - for(const auto &option : _positional_options) + for (const auto &option : _positional_options) { - if(option->is_required() && !option->is_set()) + if (option->is_required() && !option->is_set()) { is_valid = false; std::cerr << "ERROR: Option '" << option->name() << "' is required but not given!\n"; } } - for(const auto &option : _unknown_options) + for (const auto &option : _unknown_options) { std::cerr << "WARNING: Skipping unknown option '" << option << "'!\n"; } - for(const auto &option : _invalid_options) + for (const auto &option : _invalid_options) { std::cerr << "WARNING: Skipping invalid option '" << option << "'!\n"; } @@ -219,19 +219,19 @@ inline void CommandLineParser::print_help(const std::string &program_name) const { std::cout << "usage: " << program_name << " \n"; - for(const auto &option : _options) + for (const auto &option : _options) { std::cout << option.second->help() << "\n"; } - for(const auto &option : _positional_options) + for (const auto &option : _positional_options) { std::string help_to_print; // Extract help sub-string const std::string help_str = option->help(); const size_t help_pos = help_str.find(" - "); - if(help_pos != std::string::npos) + if (help_pos != std::string::npos) { help_to_print = help_str.substr(help_pos); } diff --git a/utils/command_line/EnumListOption.h b/utils/command_line/EnumListOption.h index f4ee283528..6c4146fa75 100644 --- a/utils/command_line/EnumListOption.h +++ b/utils/command_line/EnumListOption.h @@ -25,7 +25,6 @@ #define ARM_COMPUTE_UTILS_ENUMLISTOPTION #include "Option.h" - #include #include #include @@ -57,7 +56,7 @@ public: */ EnumListOption(std::string name, std::set allowed_values, std::initializer_list &&default_values); - bool parse(std::string value) override; + bool parse(std::string value) override; std::string help() const override; /** Get the values of the option. @@ -73,13 +72,17 @@ private: template inline EnumListOption::EnumListOption(std::string name, std::set allowed_values) - : Option{ std::move(name) }, _allowed_values{ std::move(allowed_values) } + : Option{std::move(name)}, _allowed_values{std::move(allowed_values)} { } template -inline EnumListOption::EnumListOption(std::string name, std::set allowed_values, std::initializer_list &&default_values) - : Option{ std::move(name), false, true }, _values{ std::forward>(default_values) }, _allowed_values{ std::move(allowed_values) } +inline EnumListOption::EnumListOption(std::string name, + std::set allowed_values, + std::initializer_list &&default_values) + : Option{std::move(name), false, true}, + _values{std::forward>(default_values)}, + _allowed_values{std::move(allowed_values)} { } @@ -90,10 +93,10 @@ bool EnumListOption::parse(std::string value) _values.clear(); _is_set = true; - std::stringstream stream{ value }; + std::stringstream stream{value}; std::string item; - while(!std::getline(stream, item, ',').fail()) + while (!std::getline(stream, item, ',').fail()) { try { @@ -102,9 +105,9 @@ bool EnumListOption::parse(std::string value) item_stream >> typed_value; - if(!item_stream.fail()) + if (!item_stream.fail()) { - if(_allowed_values.count(typed_value) == 0) + if (_allowed_values.count(typed_value) == 0) { _is_set = false; continue; @@ -115,7 +118,7 @@ bool EnumListOption::parse(std::string value) _is_set = _is_set && !item_stream.fail(); } - catch(const std::invalid_argument &) + catch (const std::invalid_argument &) { _is_set = false; } @@ -130,7 +133,7 @@ std::string EnumListOption::help() const std::stringstream msg; msg << "--" + name() + "={"; - for(const auto &value : _allowed_values) + for (const auto &value : _allowed_values) { msg << value << ","; } diff --git a/utils/command_line/EnumOption.h b/utils/command_line/EnumOption.h index 6bcfe5f14e..eb43b6c54e 100644 --- a/utils/command_line/EnumOption.h +++ b/utils/command_line/EnumOption.h @@ -25,7 +25,6 @@ #define ARM_COMPUTE_UTILS_ENUMOPTION #include "SimpleOption.h" - #include #include #include @@ -55,7 +54,7 @@ public: */ EnumOption(std::string name, std::set allowed_values, T default_value); - bool parse(std::string value) override; + bool parse(std::string value) override; std::string help() const override; /** Get the selected value. @@ -70,13 +69,13 @@ private: template inline EnumOption::EnumOption(std::string name, std::set allowed_values) - : SimpleOption{ std::move(name) }, _allowed_values{ std::move(allowed_values) } + : SimpleOption{std::move(name)}, _allowed_values{std::move(allowed_values)} { } template inline EnumOption::EnumOption(std::string name, std::set allowed_values, T default_value) - : SimpleOption{ std::move(name), std::move(default_value) }, _allowed_values{ std::move(allowed_values) } + : SimpleOption{std::move(name), std::move(default_value)}, _allowed_values{std::move(allowed_values)} { } @@ -85,14 +84,14 @@ bool EnumOption::parse(std::string value) { try { - std::stringstream stream{ value }; + std::stringstream stream{value}; T typed_value{}; stream >> typed_value; - if(!stream.fail()) + if (!stream.fail()) { - if(_allowed_values.count(typed_value) == 0) + if (_allowed_values.count(typed_value) == 0) { return false; } @@ -104,7 +103,7 @@ bool EnumOption::parse(std::string value) return false; } - catch(const std::invalid_argument &) + catch (const std::invalid_argument &) { return false; } @@ -116,7 +115,7 @@ std::string EnumOption::help() const std::stringstream msg; msg << "--" + this->name() + "={"; - for(const auto &value : _allowed_values) + for (const auto &value : _allowed_values) { msg << value << ","; } diff --git a/utils/command_line/ListOption.h b/utils/command_line/ListOption.h index b290191e08..f318e1646a 100644 --- a/utils/command_line/ListOption.h +++ b/utils/command_line/ListOption.h @@ -25,7 +25,6 @@ #define ARM_COMPUTE_UTILS_LISTOPTION #include "Option.h" - #include #include #include @@ -50,7 +49,7 @@ public: */ ListOption(std::string name, std::initializer_list &&default_values); - bool parse(std::string value) override; + bool parse(std::string value) override; std::string help() const override; /** Get the list of option values. @@ -65,7 +64,7 @@ private: template inline ListOption::ListOption(std::string name, std::initializer_list &&default_values) - : Option{ std::move(name), false, true }, _values{ std::forward>(default_values) } + : Option{std::move(name), false, true}, _values{std::forward>(default_values)} { } @@ -76,17 +75,17 @@ bool ListOption::parse(std::string value) try { - std::stringstream stream{ value }; + std::stringstream stream{value}; std::string item; - while(!std::getline(stream, item, ',').fail()) + while (!std::getline(stream, item, ',').fail()) { std::stringstream item_stream(item); T typed_value{}; item_stream >> typed_value; - if(!item_stream.fail()) + if (!item_stream.fail()) { _values.emplace_back(typed_value); } @@ -96,7 +95,7 @@ bool ListOption::parse(std::string value) return _is_set; } - catch(const std::invalid_argument &) + catch (const std::invalid_argument &) { return false; } diff --git a/utils/command_line/Option.h b/utils/command_line/Option.h index c845e5499f..b4288538b0 100644 --- a/utils/command_line/Option.h +++ b/utils/command_line/Option.h @@ -97,18 +97,17 @@ public: protected: std::string _name; - bool _is_required{ false }; - bool _is_set{ false }; + bool _is_required{false}; + bool _is_set{false}; std::string _help{}; }; -inline Option::Option(std::string name) - : _name{ std::move(name) } +inline Option::Option(std::string name) : _name{std::move(name)} { } inline Option::Option(std::string name, bool is_required, bool is_set) - : _name{ std::move(name) }, _is_required{ is_required }, _is_set{ is_set } + : _name{std::move(name)}, _is_required{is_required}, _is_set{is_set} { } diff --git a/utils/command_line/SimpleOption.h b/utils/command_line/SimpleOption.h index d76797375d..f6329c1790 100644 --- a/utils/command_line/SimpleOption.h +++ b/utils/command_line/SimpleOption.h @@ -25,7 +25,6 @@ #define ARM_COMPUTE_UTILS_SIMPLEOPTION #include "Option.h" - #include #include #include @@ -74,7 +73,7 @@ protected: template inline SimpleOption::SimpleOption(std::string name, T default_value) - : Option{ std::move(name), false, true }, _value{ std::move(default_value) } + : Option{std::move(name), false, true}, _value{std::move(default_value)} { } @@ -83,12 +82,12 @@ bool SimpleOption::parse(std::string value) { try { - std::stringstream stream{ std::move(value) }; + std::stringstream stream{std::move(value)}; stream >> _value; _is_set = !stream.fail(); return _is_set; } - catch(const std::invalid_argument &) + catch (const std::invalid_argument &) { return false; } diff --git a/utils/command_line/ToggleOption.h b/utils/command_line/ToggleOption.h index d3c68663b5..694b7bb9e6 100644 --- a/utils/command_line/ToggleOption.h +++ b/utils/command_line/ToggleOption.h @@ -25,7 +25,6 @@ #define ARM_COMPUTE_UTILS_TOGGLEOPTION #include "SimpleOption.h" - #include namespace arm_compute @@ -45,26 +44,23 @@ public: */ ToggleOption(std::string name, bool default_value); - bool parse(std::string value) override; + bool parse(std::string value) override; std::string help() const override; }; inline ToggleOption::ToggleOption(std::string name, bool default_value) - : SimpleOption -{ - std::move(name), default_value -} + : SimpleOption{std::move(name), default_value} { } inline bool ToggleOption::parse(std::string value) { - if(value == "true") + if (value == "true") { _value = true; _is_set = true; } - else if(value == "false") + else if (value == "false") { _value = false; _is_set = true; -- cgit v1.2.1