exprtk_real_benchmark.cpp File Reference

#include <cstdio>
#include <cmath>
#include <iostream>
#include <fstream>
#include <string>
#include <deque>
#include "real_type.hpp"
#include "exprtk_real_adaptor.hpp"
#include "exprtk.hpp"

Include dependency graph for exprtk_real_benchmark.cpp:

Go to the source code of this file.

Classes
struct	native< T >

Functions
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	load_expression (exprtk::symbol_table< T > &symbol_table, Sequence< exprtk::expression< T >, Allocator > &expr_seq)
template<typename T >
void	run_exprtk_benchmark (T &x, T &y, exprtk::expression< T > &expression, const std::string &expr_string)
template<typename T , typename NativeFunction >
void	run_native_benchmark (T &x, T &y, NativeFunction f, const std::string &expr_string)
template<typename T >
bool	run_parse_benchmark (exprtk::symbol_table< T > &symbol_table)
void	pgo_primer ()
void	perform_file_based_benchmark (const std::string &file_name, const std::size_t &rounds=100000)
int	main (int argc, char *argv[])
std::size_t	load_expression_file (const std::string &file_name, std::deque< std::string > &expression_list)

Variables
static const std::string	expression_list []
const std::size_t	expression_list_size = sizeof(expression_list) / sizeof(std::string)
static const real::type	lower_bound_x = real::type(-100.0)
static const real::type	lower_bound_y = real::type(-100.0)
static const real::type	upper_bound_x = real::type(+100.0)
static const real::type	upper_bound_y = real::type(+100.0)
static const real::type	delta = real::type(0.0111)
static const double	lower_bound_x_d = -100.0
static const double	lower_bound_y_d = -100.0
static const double	upper_bound_x_d = +100.0
static const double	upper_bound_y_d = +100.0
static const double	delta_d = 0.0111
const real::type	pi = 3.14159265358979323846
const double	pi_d = 3.14159265358979323846

Function Documentation

load_expression()

template<typename T , typename Allocator , template< typename, typename > class Sequence>

bool load_expression	(	exprtk::symbol_table< T > &	symbol_table,
		Sequence< exprtk::expression< T >, Allocator > &	expr_seq
	)

Definition at line 72 of file exprtk_real_benchmark.cpp.

{
   exprtk::parser<real::type> parser;
   for (std::size_t i = 0; i < expression_list_size; ++i)
   {
      exprtk::expression<real::type> expression;
      expression.register_symbol_table(symbol_table);
 
      if (!parser.compile(expression_list[i],expression))
      {
         printf("[load_expression] - Parser Error: %s\tExpression: %s\n",
                parser.error().c_str(),
                expression_list[i].c_str());
 
         return false;
      }
 
      expr_seq.push_back(expression);
   }
 
   return true;
}

References exprtk::parser< T >::compile(), exprtk::parser< T >::error(), expression_list, expression_list_size, and exprtk::expression< T >::register_symbol_table().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

load_expression_file()

std::size_t load_expression_file	(	const std::string &	file_name,
		std::deque< std::string > &	expression_list
	)

Definition at line 409 of file exprtk_real_benchmark.cpp.

{
   std::ifstream stream(file_name.c_str());
 
   if (!stream) return 0;
 
   std::string buffer;
   buffer.reserve(1024);
   std::size_t line_count = 0;
 
   while (std::getline(stream,buffer))
   {
      if (buffer.empty())
         continue;
      else if ('#' == buffer[0])
         continue;
 
      ++line_count;
      expression_list.push_back(buffer);
   }
 
   return line_count;
}

References expression_list.

Referenced by perform_file_based_benchmark().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 304 of file exprtk_real_benchmark.cpp.

{
   if (argc >= 2)
   {
      const std::string file_name = argv[1];
 
      if (argc == 2)
         perform_file_based_benchmark(file_name);
      else
         perform_file_based_benchmark(file_name,atoi(argv[2]));
 
      return 0;
   }
 
   pgo_primer();
 
   real::type x = 0;
   real::type y = 0;
 
   exprtk::symbol_table<real::type> symbol_table;
   symbol_table.add_constants();
   symbol_table.add_variable("x",x);
   symbol_table.add_variable("y",y);
 
   std::deque<exprtk::expression<real::type> > expr_list;
 
   if (!load_expression(symbol_table,expr_list))
   {
      return 1;
   }
 
   {
      std::cout << "--- EXPRTK ---" << std::endl;
      for (std::size_t i = 0; i < expr_list.size(); ++i)
      {
         run_exprtk_benchmark(x,y,expr_list[i],expression_list[i]);
      }
   }
 
   {
      std::cout << "--- NATIVE ---" << std::endl;
      double x = 0;
      double y = 0;
      run_native_benchmark(x,y,native<double>::func00,expression_list[ 0]);
      run_native_benchmark(x,y,native<double>::func01,expression_list[ 1]);
      run_native_benchmark(x,y,native<double>::func02,expression_list[ 2]);
      run_native_benchmark(x,y,native<double>::func03,expression_list[ 3]);
      run_native_benchmark(x,y,native<double>::func04,expression_list[ 4]);
      run_native_benchmark(x,y,native<double>::func05,expression_list[ 5]);
      run_native_benchmark(x,y,native<double>::func06,expression_list[ 6]);
      run_native_benchmark(x,y,native<double>::func07,expression_list[ 7]);
      run_native_benchmark(x,y,native<double>::func08,expression_list[ 8]);
      run_native_benchmark(x,y,native<double>::func09,expression_list[ 9]);
      run_native_benchmark(x,y,native<double>::func10,expression_list[10]);
      run_native_benchmark(x,y,native<double>::func11,expression_list[11]);
      run_native_benchmark(x,y,native<double>::func12,expression_list[12]);
      run_native_benchmark(x,y,native<double>::func13,expression_list[13]);
      run_native_benchmark(x,y,native<double>::func14,expression_list[14]);
      run_native_benchmark(x,y,native<double>::func15,expression_list[15]);
      run_native_benchmark(x,y,native<double>::func16,expression_list[16]);
   }
 
   {
      std::cout << "--- PARSE ----" << std::endl;
      run_parse_benchmark(symbol_table);
   }
 
   return 0;
}

References exprtk::symbol_table< T >::add_constants(), exprtk::symbol_table< T >::add_variable(), expression_list, load_expression(), perform_file_based_benchmark(), pgo_primer(), run_exprtk_benchmark(), run_native_benchmark(), and run_parse_benchmark().

Here is the call graph for this function:

perform_file_based_benchmark()

void perform_file_based_benchmark	(	const std::string &	file_name,
		const std::size_t &	rounds = 100000
	)

Definition at line 433 of file exprtk_real_benchmark.cpp.

{
   std::deque<std::string> expr_str_list;
 
   if (0 == load_expression_file(file_name,expr_str_list))
   {
      std::cout << "Failed to load any expressions from: " << file_name << "\n";
      return;
   }
 
   typedef exprtk::symbol_table<real::type> symbol_table_t;
   typedef exprtk::expression<real::type>     expression_t;
   typedef exprtk::parser<real::type>             parser_t;
 
   std::deque<expression_t> expression_list;
 
   symbol_table_t symbol_table;
 
   real::type a = 1.1;
   real::type b = 2.2;
   real::type c = 3.3;
   real::type x = 2.123456;
   real::type y = 3.123456;
   real::type z = 4.123456;
   real::type w = 5.123456;
 
   symbol_table.add_variable("a", a);
   symbol_table.add_variable("b", b);
   symbol_table.add_variable("c", c);
 
   symbol_table.add_variable("x", x);
   symbol_table.add_variable("y", y);
   symbol_table.add_variable("z", z);
   symbol_table.add_variable("w", w);
 
   exprtk::polynomial<real::type, 1> poly01;
   exprtk::polynomial<real::type, 2> poly02;
   exprtk::polynomial<real::type, 3> poly03;
   exprtk::polynomial<real::type, 4> poly04;
   exprtk::polynomial<real::type, 5> poly05;
   exprtk::polynomial<real::type, 6> poly06;
   exprtk::polynomial<real::type, 7> poly07;
   exprtk::polynomial<real::type, 8> poly08;
   exprtk::polynomial<real::type, 9> poly09;
   exprtk::polynomial<real::type,10> poly10;
   exprtk::polynomial<real::type,11> poly11;
   exprtk::polynomial<real::type,12> poly12;
 
   symbol_table.add_function("poly01", poly01);
   symbol_table.add_function("poly02", poly02);
   symbol_table.add_function("poly03", poly03);
   symbol_table.add_function("poly04", poly04);
   symbol_table.add_function("poly05", poly05);
   symbol_table.add_function("poly06", poly06);
   symbol_table.add_function("poly07", poly07);
   symbol_table.add_function("poly08", poly08);
   symbol_table.add_function("poly09", poly09);
   symbol_table.add_function("poly10", poly10);
   symbol_table.add_function("poly11", poly11);
   symbol_table.add_function("poly12", poly12);
 
   static real::type e = exprtk::details::numeric::constant::e;
   symbol_table.add_variable("e", e, true);
 
   symbol_table.add_constants();
 
   {
      parser_t parser;
 
      for (std::size_t i = 0; i < expr_str_list.size(); ++i)
      {
         expression_t expression;
         expression.register_symbol_table(symbol_table);
 
         if (!parser.compile(expr_str_list[i],expression))
         {
            printf("[perform_file_based_benchmark] - Parser Error: %s\tExpression: %s\n",
                   parser.error().c_str(),
                   expr_str_list[i].c_str());
 
            return;
         }
 
         expression_list.push_back(expression);
      }
   }
 
   exprtk::timer total_timer;
 
   real::type single_eval_total_time = 0.0;
 
   total_timer.start();
 
   for (std::size_t i = 0; i < expression_list.size(); ++i)
   {
      expression_t& e = expression_list[i];
 
      exprtk::timer timer;
 
      a = real::type(1.1);
      b = real::type(2.2);
      c = real::type(3.3);
      x = real::type(2.123456);
      y = real::type(3.123456);
      z = real::type(4.123456);
      w = real::type(5.123456);
 
      timer.start();
      real::type sum = 0.0;
 
      for (std::size_t r = 0; r < rounds; ++r)
      {
         sum += e.value();
         std::swap(a,b);
         std::swap(x,y);
      }
 
      timer.stop();
 
      printf("Expression %3d of %3d %9.3f ns\t%10d ns\t(%30.10f)  '%s'\n",
             static_cast<int>(i + 1),
             static_cast<int>(expression_list.size()),
             (timer.time() * 1000000000.0) / (1.0 * rounds),
             static_cast<int>(timer.time() * 1000000000.0),
             static_cast<double>(sum),
             expr_str_list[i].c_str());
 
      fflush(stdout);
 
      single_eval_total_time += (timer.time() * 1000000000.0) / (1.0 * rounds);
   }
 
   total_timer.stop();
 
   printf("[*] Number Of Evals:        %15.0f\n",
          rounds * (expression_list.size() * 1.0));
 
   printf("[*] Total Time:             %9.3fsec\n",
          total_timer.time());
 
   printf("[*] Total Single Eval Time: %9.3fms\n",
          static_cast<double>(single_eval_total_time / 1000000.0));
}

References exprtk::details::numeric::constant::e, expression_list, load_expression_file(), rounds, exprtk::timer::start(), exprtk::timer::stop(), and exprtk::timer::time().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

pgo_primer()

void pgo_primer

(

)

Definition at line 374 of file exprtk_real_benchmark.cpp.

{
   static const real::type lower_bound_x = -50.0;
   static const real::type lower_bound_y = -50.0;
   static const real::type upper_bound_x = +50.0;
   static const real::type upper_bound_y = +50.0;
   static const real::type delta = 0.07;
 
   real::type total = 0.0;
 
   for (real::type x = lower_bound_x; x <= upper_bound_x; x += delta)
   {
      for (real::type y = lower_bound_y; y <= upper_bound_y; y += delta)
      {
         total += native<double>::func00(x,y);
         total += native<double>::func01(x,y);
         total += native<double>::func02(x,y);
         total += native<double>::func03(x,y);
         total += native<double>::func04(x,y);
         total += native<double>::func05(x,y);
         total += native<double>::func06(x,y);
         total += native<double>::func07(x,y);
         total += native<double>::func08(x,y);
         total += native<double>::func09(x,y);
         total += native<double>::func10(x,y);
         total += native<double>::func11(x,y);
         total += native<double>::func12(x,y);
         total += native<double>::func13(x,y);
         total += native<double>::func14(x,y);
         total += native<double>::func15(x,y);
         total += native<double>::func16(x,y);
      }
   }
}

References delta, native< T >::func00(), native< T >::func01(), native< T >::func02(), native< T >::func03(), native< T >::func04(), native< T >::func05(), native< T >::func06(), native< T >::func07(), native< T >::func08(), native< T >::func09(), native< T >::func10(), native< T >::func11(), native< T >::func12(), native< T >::func13(), native< T >::func14(), native< T >::func15(), native< T >::func16(), lower_bound_x, lower_bound_y, upper_bound_x, and upper_bound_y.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

run_exprtk_benchmark()

template<typename T >

void run_exprtk_benchmark	(	T &	x,
		T &	y,
		exprtk::expression< T > &	expression,
		const std::string &	expr_string
	)

Definition at line 97 of file exprtk_real_benchmark.cpp.

{
   T total = T(0);
   unsigned int count = 0;
 
   exprtk::timer timer;
   timer.start();
 
   for (x = lower_bound_x; x <= upper_bound_x; x += delta)
   {
      for (y = lower_bound_y; y <= upper_bound_y; y += delta)
      {
         total += expression.value();
         ++count;
      }
   }
 
   timer.stop();
 
   if (T(0) != total)
      printf("[exprtk] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
             timer.time(),
             count / timer.time(),
             expr_string.c_str());
   else
      printf("run_exprtk_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
}

References delta, lower_bound_x, lower_bound_y, exprtk::timer::start(), exprtk::timer::stop(), exprtk::timer::time(), upper_bound_x, upper_bound_y, and exprtk::expression< T >::value().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

run_native_benchmark()

template<typename T , typename NativeFunction >

void run_native_benchmark	(	T &	x,
		T &	y,
		NativeFunction	f,
		const std::string &	expr_string
	)

Definition at line 130 of file exprtk_real_benchmark.cpp.

{
   T total = T(0);
   unsigned int count = 0;
 
   exprtk::timer timer;
   timer.start();
 
   for (x = lower_bound_x_d; x <= upper_bound_x_d; x += delta_d)
   {
      for (y = lower_bound_y_d; y <= upper_bound_y_d; y += delta_d)
      {
         total += f(x,y);
         ++count;
      }
   }
 
   timer.stop();
 
   if (T(0) != total)
      printf("[native] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
             timer.time(),
             count / timer.time(),
             expr_string.c_str());
   else
      printf("run_native_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
}

References delta_d, lower_bound_x_d, lower_bound_y_d, exprtk::timer::start(), exprtk::timer::stop(), exprtk::timer::time(), upper_bound_x_d, and upper_bound_y_d.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

run_parse_benchmark()

template<typename T >

bool run_parse_benchmark

(

exprtk::symbol_table< T > &

symbol_table

)

Definition at line 159 of file exprtk_real_benchmark.cpp.

{
   static const std::size_t rounds = 100000;
   exprtk::parser<real::type> parser;
   exprtk::expression<real::type> expression;
 
   expression.register_symbol_table(symbol_table);
 
   for (std::size_t i = 0; i < expression_list_size; ++i)
   {
      exprtk::timer timer;
      timer.start();
 
      for (std::size_t r = 0; r < rounds; ++r)
      {
         if (!parser.compile(expression_list[i],expression))
         {
            printf("[run_parse_benchmark] - Parser Error: %s\tExpression: %s\n",
                   parser.error().c_str(),
                   expression_list[i].c_str());
 
            return false;
         }
      }
 
      timer.stop();
 
      printf("[parse] Total Time:%12.8f  Rate:%14.3fparse/sec Expression: %s\n",
             timer.time(),
             rounds / timer.time(),
             expression_list[i].c_str());
   }
 
   return true;
}

References exprtk::parser< T >::compile(), exprtk::parser< T >::error(), expression_list, expression_list_size, exprtk::expression< T >::register_symbol_table(), rounds, exprtk::timer::start(), exprtk::timer::stop(), and exprtk::timer::time().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

delta

const real::type delta = real::type(0.0111)

static

Definition at line 60 of file exprtk_real_benchmark.cpp.

Referenced by pgo_primer(), and run_exprtk_benchmark().

delta_d

const double delta_d = 0.0111

static

Definition at line 66 of file exprtk_real_benchmark.cpp.

Referenced by run_native_benchmark().

expression_list

const std::string expression_list[]

static

Initial value:

=
{
   "(y + x)",
   "2 * (y + x)",
   "(2 * y + 2 * x)",
   "((1.23 * x^2) / y) - 123.123",
   "(y + x / y) * (x - y / x)",
   "x / ((x + y) + (x - y)) / y",
   "1 - ((x * y) + (y / x)) - 3",
   "(5.5 + x) + (2 * x - 2 / 3 * y) * (x / 3 + y / 4) + (y + 7.7)",
   "1.1x^1 + 2.2y^2 - 3.3x^3 + 4.4y^15 - 5.5x^23 + 6.6y^55",
   "sin(2 * x) + cos(pi / y)",
   "1 - sin(2 * x) + cos(pi / y)",
   "sqrt(111.111 - sin(2 * x) + cos(pi / y) / 333.333)",
   "(x^2 / sin(2 * pi / y)) - x / 2",
   "x + (cos(y - sin(2 / x * pi)) - sin(x - cos(2 * y / pi))) - y",
   "clamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)",
   "max(3.33, min(sqrt(1 - sin(2 * x) + cos(pi / y) / 3), 1.11))",
   "if((y + (x * 2.2)) <= (x + y + 1.1), x - y, x * y) + 2 * pi / x"
}

Definition at line 32 of file exprtk_real_benchmark.cpp.

{
   "(y + x)",
   "2 * (y + x)",
   "(2 * y + 2 * x)",
   "((1.23 * x^2) / y) - 123.123",
   "(y + x / y) * (x - y / x)",
   "x / ((x + y) + (x - y)) / y",
   "1 - ((x * y) + (y / x)) - 3",
   "(5.5 + x) + (2 * x - 2 / 3 * y) * (x / 3 + y / 4) + (y + 7.7)",
   "1.1x^1 + 2.2y^2 - 3.3x^3 + 4.4y^15 - 5.5x^23 + 6.6y^55",
   "sin(2 * x) + cos(pi / y)",
   "1 - sin(2 * x) + cos(pi / y)",
   "sqrt(111.111 - sin(2 * x) + cos(pi / y) / 333.333)",
   "(x^2 / sin(2 * pi / y)) - x / 2",
   "x + (cos(y - sin(2 / x * pi)) - sin(x - cos(2 * y / pi))) - y",
   "clamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)",
   "max(3.33, min(sqrt(1 - sin(2 * x) + cos(pi / y) / 3), 1.11))",
   "if((y + (x * 2.2)) <= (x + y + 1.1), x - y, x * y) + 2 * pi / x"
};

Referenced by load_expression(), load_expression_file(), main(), main(), perform_file_based_benchmark(), pgo_primer(), run_parse_benchmark(), run_test05(), run_test09(), run_test10(), run_test14(), run_test15(), run_test16(), run_test17(), run_test18(), run_test19(), run_test21(), exprtk::parser< T >::simplify(), and test_gen().

expression_list_size

const std::size_t expression_list_size = sizeof(expression_list) / sizeof(std::string)

Definition at line 53 of file exprtk_real_benchmark.cpp.

Referenced by load_expression(), pgo_primer(), run_parse_benchmark(), run_test09(), run_test10(), run_test18(), and run_test21().

lower_bound_x

const real::type lower_bound_x = real::type(-100.0)

static

Definition at line 56 of file exprtk_real_benchmark.cpp.

Referenced by pgo_primer(), and run_exprtk_benchmark().

lower_bound_x_d

const double lower_bound_x_d = -100.0

static

Definition at line 62 of file exprtk_real_benchmark.cpp.

Referenced by run_native_benchmark().

lower_bound_y

const real::type lower_bound_y = real::type(-100.0)

static

Definition at line 57 of file exprtk_real_benchmark.cpp.

Referenced by pgo_primer(), and run_exprtk_benchmark().

lower_bound_y_d

const double lower_bound_y_d = -100.0

static

Definition at line 63 of file exprtk_real_benchmark.cpp.

Referenced by run_native_benchmark().

pi

const real::type pi = 3.14159265358979323846

Definition at line 195 of file exprtk_real_benchmark.cpp.

Referenced by native< T >::func09(), native< T >::func10(), native< T >::func11(), native< T >::func12(), native< T >::func13(), native< T >::func14(), native< T >::func15(), and native< T >::func16().

pi_d

const double pi_d = 3.14159265358979323846

Definition at line 196 of file exprtk_real_benchmark.cpp.

Referenced by native< T >::func09(), native< T >::func10(), native< T >::func11(), native< T >::func12(), native< T >::func13(), native< T >::func14(), native< T >::func15(), and native< T >::func16().

upper_bound_x

const real::type upper_bound_x = real::type(+100.0)

static

Definition at line 58 of file exprtk_real_benchmark.cpp.

Referenced by pgo_primer(), and run_exprtk_benchmark().

upper_bound_x_d

const double upper_bound_x_d = +100.0

static

Definition at line 64 of file exprtk_real_benchmark.cpp.

Referenced by run_native_benchmark().

upper_bound_y

const real::type upper_bound_y = real::type(+100.0)

static

Definition at line 59 of file exprtk_real_benchmark.cpp.

Referenced by pgo_primer(), and run_exprtk_benchmark().

upper_bound_y_d

const double upper_bound_y_d = +100.0

static

Definition at line 65 of file exprtk_real_benchmark.cpp.

Referenced by run_native_benchmark().