WIP: benchmarking various tree representations and linear allocator

CMakeLists.txt

@@ -35,10 +35,10 @@ endif()
 # Enable C++11 support in all compilers. SymEngine will not compile unless
 # the C++11 support is enabled.
 if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|Intel")
-    set(CXX11_OPTIONS "-std=c++11")
+    set(CXX11_OPTIONS "-std=c++17")
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "PGI")
     # pgcpp
-    set(CXX11_OPTIONS "--gnu --c++11 -D__GXX_EXPERIMENTAL_CXX0X__")
+    set(CXX11_OPTIONS "--gnu --c++17 -D__GXX_EXPERIMENTAL_CXX0X__")
 endif ()
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${CXX11_OPTIONS}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${CXX11_OPTIONS}")

benchmarks/parsing.cpp

@@ -3,68 +3,29 @@
 #include <symengine/parser.h>
 #include <symengine/parser/parser.h>
 
-using SymEngine::Basic;
-using SymEngine::RCP;
 using SymEngine::print_stack_on_segfault;
 using SymEngine::parse;
-using SymEngine::parse_old;
 
 int main(int argc, char *argv[])
 {
     SymEngine::print_stack_on_segfault();
 
-    RCP<const Basic> a;
     int N;
 
-    auto t1 = std::chrono::high_resolution_clock::now();
-    a = parse("0");
-    auto t2 = std::chrono::high_resolution_clock::now();
-    std::cout << "parse('0') = " << *a << ": "
-              << std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1)
-                     .count()
-              << "us" << std::endl;
-
-    N = 5000;
+    N = 50000;
     std::string text;
-    std::string t0 = "(x + y - sin(x)/(z**2-4) - x**(y**z))";
+    std::string t0 = "(a*z+3+2*x + 3*y - x/(z**2-4) - x**(y**z))";
+    text.reserve(10000000);
     text = t0;
+    std::cout << "Construct" << std::endl;
     for (int i = 0; i < N; i++) {
-        text = text + " * " + t0;
+        text.append(" * " + t0);
     }
 
-    t1 = std::chrono::high_resolution_clock::now();
-    a = parse(text);
-    t2 = std::chrono::high_resolution_clock::now();
-    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1)
-                     .count()
-              << "ms" << std::endl;
-    std::cout << *a << std::endl;
-
-    t1 = std::chrono::high_resolution_clock::now();
-    a = parse_old(text);
-    t2 = std::chrono::high_resolution_clock::now();
-    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1)
-                     .count()
-              << "ms" << std::endl;
-    std::cout << *a << std::endl;
-
-    /* ------------------------------------------------- */
-
-    N = 3000;
-    t1 = std::chrono::high_resolution_clock::now();
-    for (int i = 0; i < N; i++) {
-        a = parse(t0);
-    }
-    t2 = std::chrono::high_resolution_clock::now();
-    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1)
-                     .count()
-              << "ms" << std::endl;
-
-    t1 = std::chrono::high_resolution_clock::now();
-    for (int i = 0; i < N; i++) {
-        a = parse_old(t0);
-    }
-    t2 = std::chrono::high_resolution_clock::now();
+    std::cout << "Parse" << std::endl;
+    auto t1 = std::chrono::high_resolution_clock::now();
+    parse(text);
+    auto t2 = std::chrono::high_resolution_clock::now();
     std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1)
                      .count()
               << "ms" << std::endl;

symengine/CMakeLists.txt

@@ -8,7 +8,7 @@ endif()
 
 if (WITH_GENERATE_PARSER)
     add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/parser/parser.tab.cc
-                      COMMAND ${BISON_EXECUTABLE} -d parser.yy
+                      COMMAND ${BISON_EXECUTABLE} -Wall -d parser.yy
                       DEPENDS parser/parser.yy
                       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/parser
                      )

symengine/constants.cpp

@@ -3,6 +3,7 @@
 #include <symengine/infinity.h>
 #include <symengine/pow.h>
 #include <symengine/nan.h>
+#include <symengine/parser/alloc.h>
 
 namespace SymEngine
 {
@@ -35,6 +36,8 @@ int Constant::compare(const Basic &o) const
     return name_ < s.name_ ? -1 : 1;
 }
 
+Allocator al(1000000000);
+
 RCP<const Integer> zero = integer(0);
 RCP<const Integer> one = integer(1);
 RCP<const Integer> minus_one = integer(-1);

symengine/cwrapper.cpp

@@ -503,17 +503,17 @@ CWRAPPER_OUTPUT_TYPE basic_assign(basic a, const basic b)
 CWRAPPER_OUTPUT_TYPE basic_parse(basic b, const char *str)
 {
     CWRAPPER_BEGIN
-    b->m = SymEngine::parse(str);
+    //b->m = SymEngine::parse(str);
     CWRAPPER_END
 }
 
 CWRAPPER_OUTPUT_TYPE basic_parse2(basic b, const char *str, int convert_xor)
 {
     CWRAPPER_BEGIN
     if (convert_xor > 0) {
-        b->m = SymEngine::parse(str);
+        //b->m = SymEngine::parse(str);
     } else {
-        b->m = SymEngine::parse(str, false);
+        //b->m = SymEngine::parse(str, false);
     }
     CWRAPPER_END
 }

symengine/expression.cpp

@@ -18,7 +18,7 @@ std::string poly_print(const Expression &x)
 
 Expression::Expression(const std::string &s)
 {
-    m_basic = parse(s);
+    //m_basic = parse(s);
 }
 
 } // SymEngine

symengine/parser.h

@@ -6,7 +6,7 @@
 namespace SymEngine
 {
 
-RCP<const Basic> parse(const std::string &s, bool convert_xor = true);
+void parse(const std::string &s);
 RCP<const Basic> parse_old(const std::string &s, bool convert_xor = true);
 }
 

symengine/parser/alloc.h

@@ -0,0 +1,52 @@
+#ifndef SYMENGINE_PARSER_ALLOC_H
+#define SYMENGINE_PARSER_ALLOC_H
+
+#define ALIGNMENT 8
+
+inline size_t align(size_t n) {
+  return (n + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
+}
+
+class Allocator
+{
+    void *start;
+    size_t current_pos;
+    size_t size;
+public:
+    Allocator(size_t s) {
+        start = malloc(s);
+        if (start == nullptr) {
+            throw std::runtime_error("malloc failed.");
+        }
+        current_pos = (size_t)start;
+        current_pos = align(current_pos);
+        size = s;
+    }
+
+    void *allocate(size_t s) {
+        if (start == nullptr) {
+            throw std::runtime_error("malloc failed 2.");
+        }
+        size_t addr = current_pos;
+        /*
+        std::cout << "start:" << (size_t)start << std::endl;
+        std::cout << "addr:" << addr << std::endl;
+        std::cout << "size:" << size << std::endl;
+        std::cout << "s:" << s << std::endl;
+        std::cout << "align(s):" << align(s) << std::endl;
+        */
+        current_pos += align(s);
+        if (current_pos - (size_t)start > size) {
+            throw std::runtime_error("Linear allocator too small.");
+        }
+        return (void*)addr;
+    }
+
+    template <typename T, typename... Args> T* make_new(Args &&... args) {
+        return new(allocate(sizeof(T))) T(std::forward<Args>(args)...);
+        // To test the default "new", comment the above and uncomment this:
+        //return new T(std::forward<Args>(args)...);
+    }
+};
+
+#endif

symengine/parser/parser.cpp

@@ -6,24 +6,21 @@
 namespace SymEngine
 {
 
-RCP<const Basic> parse(const std::string &s, bool convert_xor)
+void parse(const std::string &s)
 {
     // This is expensive:
     Parser p;
     // If you need to parse multiple strings, initialize Parser first, then
     // call Parser::parse() repeatedly.
-    return p.parse(s, convert_xor);
+    p.parse(s);
 }
 
-RCP<const Basic> Parser::parse(const std::string &input, bool convert_xor)
+void Parser::parse(const std::string &input)
 {
     inp = input;
-    if (convert_xor) {
-        std::replace(inp.begin(), inp.end(), '^', '@');
-    }
     m_tokenizer.set_string(inp);
     if (yyparse(*this) == 0)
-        return this->res;
+        return;
     throw ParseError("Parsing Unsuccessful");
 }
 
@@ -283,20 +280,15 @@ Parser::parse_implicit_mul(const std::string &expr)
     char *endptr = 0;
     std::strtod(startptr, &endptr);
 
-    RCP<const Basic> num = one, sym;
-
     // Numerical part of the result of e.g. "100x";
     size_t length = endptr - startptr;
     std::string lexpr = std::string(startptr, length);
-    num = parse_numeric(lexpr);
+    RCP<const Basic> num = parse_numeric(lexpr);
 
     // get the rest of the string
     lexpr = std::string(startptr + length, expr.length() - length);
-    if (lexpr.length() == 0) {
-        sym = one;
-    } else {
-        sym = parse_identifier(lexpr);
-    }
+    SYMENGINE_ASSERT(lexpr.length() > 0);
+    RCP<const Basic> sym = parse_identifier(lexpr);
     return std::make_tuple(num, sym);
 }
 

symengine/parser/parser.h

@@ -35,7 +35,7 @@ class Parser
     Tokenizer m_tokenizer;
     RCP<const Basic> res;
 
-    RCP<const Basic> parse(const std::string &input, bool convert_xor = true);
+    void parse(const std::string &input);
     int parse();
 
     RCP<const Basic> functionify(const std::string &name, vec_basic &params);