exprtk_memleak_test.cpp

Go to the documentation of this file.

/*
 **************************************************************
 *         C++ Mathematical Expression Toolkit Library        *
 *                                                            *
 * ExprTk Memory Leak Test                                    *
 * Author: Arash Partow (1999-2016)                           *
 * URL: http://www.partow.net/programming/exprtk/index.html   *
 *                                                            *
 * Copyright notice:                                          *
 * Free use of the Mathematical Expression Toolkit Library is *
 * permitted under the guidelines and in accordance with the  *
 * most current version of the Common Public License.         *
 * http://www.opensource.org/licenses/cpl1.0.php              *
 *                                                            *
 **************************************************************
*/
 
 
#include <cstdio>
#include <fstream>
#include <iostream>
#include <string>
#include <deque>
 
#include "exprtk.hpp"
 
template <typename Allocator,
          template <typename,typename> class Sequence>
inline std::size_t load_expressions(const std::string& file_name,
                                    Sequence<std::string,Allocator>& sequence)
{
   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))
   {
      ++line_count;
      sequence.push_back(buffer);
   }
   return line_count;
}
 
int main()
{
   std::deque<std::string> expr_str_list;
 
   load_expressions("pgo_expression_list.txt",expr_str_list);
 
   typedef std::deque<exprtk::expression<double> > exprlist_t;
   exprtk::symbol_table<double> symbol_table;
 
   static const std::size_t rounds = 100;
 
   exprtk::timer timer;
   timer.start();
   for (std::size_t r = 0; r < rounds; ++r)
   {
      exprlist_t expression_list;
      symbol_table.add_constants();
      symbol_table.create_variable("x",2.2);
      symbol_table.create_variable("y",3.3);
      symbol_table.create_variable("z",4.4);
      symbol_table.create_variable("w",5.5);
 
      exprtk::parser<double> parser;
      exprtk::expression<double> temp_expr;
 
      temp_expr.register_symbol_table(symbol_table);
 
      for (std::size_t i = 0; i < expr_str_list.size(); ++i)
      {
         if (!parser.compile(expr_str_list[i],temp_expr))
         {
            printf("[load_expression] - [%04d] Parser Error: %s\tExpression: %s\n",
                     i,
                     parser.error().c_str(),
                     expr_str_list[i].c_str());
         }
         else
            expression_list.push_back(temp_expr);
      }
 
      for (std::size_t i = 0; i < expression_list.size(); ++i)
      {
         expression_list[i].value();
      }
 
      if (0 == (r % 10))
      {
         std::cout << "Round: " << r << std::endl;
      }
   }
   timer.stop();
 
   printf("Total Time:%12.8fsec Rate:%15.5fcompiles/sec\n",
           timer.time(),
           (rounds * expr_str_list.size()) / timer.time());
 
 
 
   return 0;
}