Compute Library: tests/framework/instruments/Measurement.h Source File

 /*

-  * Copyright (c) 2017 ARM Limited.

-  *

-  * SPDX-License-Identifier: MIT

-  *

-  * Permission is hereby granted, free of charge, to any person obtaining a copy

-  * of this software and associated documentation files (the "Software"), to

-  * deal in the Software without restriction, including without limitation the

-  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

-  * sell copies of the Software, and to permit persons to whom the Software is

-  * furnished to do so, subject to the following conditions:

-  *

-  * The above copyright notice and this permission notice shall be included in all

-  * copies or substantial portions of the Software.

-  *

-  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

-  * SOFTWARE.

-  */

- #ifndef ARM_COMPUTE_TEST_MEASUREMENT

- #define ARM_COMPUTE_TEST_MEASUREMENT

-

- #include "../Utils.h"

-

- #include <ostream>

- #include <string>

-

- namespace arm_compute

- {

- namespace test

- {

- namespace framework

- {

- struct IMeasurement

- {

-     explicit IMeasurement(std::string unit)

-         : unit{ std::move(unit) }

-     {

-     }

-

-     std::string unit;

- };

-

- template <typename T>

- struct TypedMeasurement : public IMeasurement

- {

-     TypedMeasurement(T value, std::string unit)

-         : IMeasurement(std::move(unit)), value{ value }

-     {

-     }

-

-     T value;

- };

-

- template <typename T>

- inline std::ostream &operator<<(std::ostream &os, const TypedMeasurement<T> &measurement)

- {

-     os << measurement.value << measurement.unit;

-     return os;

- }

-

- struct Measurement : public TypedMeasurement<double>

- {

-     using TypedMeasurement::TypedMeasurement;

-

-     template <typename T>

-     Measurement(TypedMeasurement<T> measurement)

-         : Measurement(measurement.value, measurement.unit)

-     {

-     }

- };

- } // namespace framework

- } // namespace test

- } // namespace arm_compute

- #endif /* ARM_COMPUTE_TEST_MEASUREMENT */

-arm_compute::test::framework::IMeasurement
Abstract measurement.
Definition: Measurement.h:42

-arm_compute::test::framework::TypedMeasurement
Measurement of a specific type.
Definition: Measurement.h:58

-arm_compute::test::framework::IMeasurement::unit
std::string unit
Definition: Measurement.h:53

-arm_compute::test::framework::Measurement
Generic measurement that stores values as double.
Definition: Measurement.h:85

-arm_compute::test::framework::TypedMeasurement::value
T value
Definition: Measurement.h:70

-arm_compute::test::framework::Measurement::Measurement
Measurement(TypedMeasurement< T > measurement)
Conversion constructor.
Definition: Measurement.h:94

-arm_compute::test::framework::TypedMeasurement::TypedMeasurement
TypedMeasurement(T value, std::string unit)
Constructor.
Definition: Measurement.h:65

-arm_compute::test::framework::IMeasurement::IMeasurement
IMeasurement(std::string unit)
Constructor.
Definition: Measurement.h:48

+Go to the documentation of this file. /*
  * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
  * deal in the Software without restriction, including without limitation the
  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  * sell copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 #ifndef ARM_COMPUTE_TEST_MEASUREMENT
 #define ARM_COMPUTE_TEST_MEASUREMENT

 #include "../Utils.h"
 #include "arm_compute/core/Error.h"

 #include <list>
 #include <ostream>
 #include <string>

 namespace arm_compute
 {
 namespace test
 {
 namespace framework
 {
 struct Measurement
 {
     struct Value
     {
         Value(bool is_floating)
             : v{ 0 }, is_floating_point(is_floating)
         {
         }

         friend std::ostream &operator<<(std::ostream &os, const Value &value)
         {
             if(value.is_floating_point)
             {
                 os << arithmetic_to_string(value.v.floating_point, 4);
             }
             else
             {
                 os << arithmetic_to_string(value.v.integer);
             }
             return os;
         }
         std::string to_string() const
         {
             std::stringstream ss;
             ss << *this;
             return ss.str();
         }
         Value operator+(Value b) const
         {
             if(is_floating_point)
             {
                 b.v.floating_point += v.floating_point;
             }
             else
             {
                 b.v.integer += v.integer;
             }
             return b;
         }

         Value operator-(Value b) const
         {
             if(is_floating_point)
             {
                 b.v.floating_point -= v.floating_point;
             }
             else
             {
                 b.v.integer -= v.integer;
             }
             return b;
         }

         Value operator*(Value b) const
         {
             if(is_floating_point)
             {
                 b.v.floating_point *= v.floating_point;
             }
             else
             {
                 b.v.integer *= v.integer;
             }
             return b;
         }

         Value operator/(int b) const
         {
             Value res(is_floating_point);
             if(is_floating_point)
             {
                 res.v.floating_point = v.floating_point / b;
             }
             else
             {
                 res.v.integer = v.integer / b;
             }
             return res;
         }

         Value &operator-=(const Value &b)
         {
             if(is_floating_point)
             {
                 v.floating_point -= b.v.floating_point;
             }
             else
             {
                 v.integer -= b.v.integer;
             }
             return *this;
         }

         bool operator<(const Value &b) const
         {
             if(is_floating_point)
             {
                 return v.floating_point < b.v.floating_point;
             }
             else
             {
                 return v.integer < b.v.integer;
             }
         }

         static double relative_standard_deviation(const Value &variance, const Value &mean)
         {
             if(variance.is_floating_point)
             {
                 return 100.0 * sqrt(variance.v.floating_point) / mean.v.floating_point;
             }
             else
             {
                 return 100.0 * sqrt(static_cast<double>(variance.v.integer)) / mean.v.integer;
             }
         }

         union
             {
                 double        floating_point;
                 long long int integer;
             } v;
         bool is_floating_point;
     };

     bool operator<(const Measurement &b) const
     {
         return _value < b.value();
     }

     friend inline std::ostream &operator<<(std::ostream &os, const Measurement &measurement)
     {
         os << measurement._value << " " << measurement._unit;
         return os;
     }

     template < typename Floating, typename std::enable_if < !std::is_integral<Floating>::value, int >::type = 0 >
     Measurement(Floating v, std::string unit, std::list<std::string> raw = {})
         : _unit(unit), _raw_data(std::move(raw)), _value(true)
     {
         _value.v.floating_point = static_cast<double>(v);
         if(_raw_data.empty())
         {
             _raw_data = { _value.to_string() };
         }
     }

     template <typename Integer, typename std::enable_if<std::is_integral<Integer>::value, int>::type = 0>
     Measurement(Integer v, std::string unit, std::list<std::string> raw = {})
         : _unit(unit), _raw_data(std::move(raw)), _value(false)
     {
         _value.v.integer = static_cast<long long int>(v);
         if(_raw_data.empty())
         {
             _raw_data = { _value.to_string() };
         }
     }

     const std::string &unit() const
     {
         return _unit;
     }

     const std::list<std::string> &raw_data() const
     {
         return _raw_data;
     }

     const Value &value() const
     {
         return _value;
     }

 private:
     std::string            _unit;
     std::list<std::string> _raw_data;
     Value                  _value;
 };

 } // namespace framework
 } // namespace test
 } // namespace arm_compute
 #endif /* ARM_COMPUTE_TEST_MEASUREMENT */
arm_compute::test::framework::Measurement::Value::operator+
Value operator+(Value b) const
Add with another value and return the sum.
Definition: Measurement.h:83

+arm_compute::test::framework::Measurement::Value::floating_point
double floating_point
Definition: Measurement.h:213

+arm_compute::test::framework::Measurement::Value::relative_standard_deviation
static double relative_standard_deviation(const Value &variance, const Value &mean)
Get the relative standard deviation to a given distribution as a percentage.
Definition: Measurement.h:198

+arm_compute::test::framework::Measurement::value
const Value & value() const
Accessor for the stored value.
Definition: Measurement.h:301

+arm_compute::test::framework::Measurement
Generic measurement that stores values as either double or long long int.
Definition: Measurement.h:41

+arm_compute::test::framework::Measurement::Value
Measurement value.
Definition: Measurement.h:44

+arm_compute
This file contains all available output stages for GEMMLowp on OpenCL.
Definition: 00_introduction.dox:1

+arm_compute::test::framework::Measurement::Value::operator/
Value operator/(int b) const
Return the stored value divided by an integer.
Definition: Measurement.h:140

+arm_compute::test::framework::Measurement::operator<<
friend std::ostream & operator<<(std::ostream &os, const Measurement &measurement)
Stream output operator to print the measurement.
Definition: Measurement.h:239

+arm_compute::test::framework::Measurement::Value::operator-=
Value & operator-=(const Value &b)
Subtract another value and return the updated stored value.
Definition: Measurement.h:160

+arm_compute::test::framework::Measurement::Value::integer
long long int integer
Definition: Measurement.h:214

+arm_compute::test::framework::Measurement::Value::v
union arm_compute::test::framework::Measurement::Value::@1 v
Stored value.

+Error.h

+arm_compute::test::framework::Measurement::Value::operator<<
friend std::ostream & operator<<(std::ostream &os, const Value &value)
Add the value stored to the stream as a string.
Definition: Measurement.h:57

+arm_compute::test::framework::Measurement::raw_data
const std::list< std::string > & raw_data() const
Accessor for the raw data.
Definition: Measurement.h:292

+arm_compute::test::framework::Measurement::Value::is_floating_point
bool is_floating_point
Is the stored value floating point or integer ?
Definition: Measurement.h:216

+arm_compute::test::framework::Measurement::Value::to_string
std::string to_string() const
Convert the value stored to string.
Definition: Measurement.h:71

+arm_compute::test::framework::Measurement::Value::operator-
Value operator-(Value b) const
Subtract with another value and return the result.
Definition: Measurement.h:102

+arm_compute::test::framework::Measurement::Measurement
Measurement(Floating v, std::string unit, std::list< std::string > raw={})
Constructor to store a floating point value.
Definition: Measurement.h:252

+arm_compute::test::framework::Measurement::Value::operator<
bool operator<(const Value &b) const
Compare the stored value with another value.
Definition: Measurement.h:179

+arm_compute::test::framework::Measurement::operator<
bool operator<(const Measurement &b) const
Compare the stored value with another value.
Definition: Measurement.h:225

+arm_compute::test::validation::b
CLTensor b
Definition: GEMM.cpp:122

+arm_compute::test::framework::Measurement::unit
const std::string & unit() const
Accessor for the unit of the measurement.
Definition: Measurement.h:283

+arm_compute::test::framework::Measurement::Value::operator*
Value operator*(Value b) const
Multiple with another value and return the result.
Definition: Measurement.h:121

+arm_compute::test::arithmetic_to_string
std::string arithmetic_to_string(T val, int decimal_places=0)
Create a string with the arithmetic value in full precision.
Definition: Utils.h:164

+arm_compute::test::framework::Measurement::Measurement
Measurement(Integer v, std::string unit, std::list< std::string > raw={})
Constructor to store an integer value.
Definition: Measurement.h:269

+arm_compute::test::framework::Measurement::Value::Value
Value(bool is_floating)
Constructor.
Definition: Measurement.h:50