Change all deque to stable_vector, add some g_d_o timers for #904 investigation

Timers now run only in `-_debug` since they slow things down

`-_debug` now implies `-verbose`

`-verbose` now sorts the timer output in descending cost order

Author: hsutter

Diff for: source/common.h

@@ -38,6 +38,7 @@
 #include <cstdint>
 #include <iomanip>
 #include <iterator>
+#include <memory>
 #include <map>
 #include <string>
 #include <string_view>
@@ -887,12 +888,20 @@ static cmdline_processor::register_flag cmd_gen_version(
     []{ cmdline.gen_version(); }
 );
 
+static auto flag_verbose = false;
+static cmdline_processor::register_flag cmd_verbose(
+    9,
+    "verbose",
+    "Print verbose output and statistics",
+    []{ flag_verbose = true; }
+);
+
 static auto flag_internal_debug = false;
 static cmdline_processor::register_flag cmd_internal_debug(
     0,
     "_debug",
-    "Generate internal debug instrumentation",
-    []{ flag_internal_debug = true; }
+    "Generate internal debug data, implies -verbose",
+    []{ flag_internal_debug = true; flag_verbose = true; }
 );
 
 static auto flag_print_colon_errors = false;
@@ -981,14 +990,14 @@ class stable_vector
 
     std::vector< std::vector<T> > data;
 
-    auto add_segment() -> void {
-        data.push_back( {} );
+    auto add_segment( std::initializer_list<T> init = {} ) -> void {
+        data.push_back( init );
         data.back().reserve(PageSize);
     }
 
 public:
-    stable_vector() {
-        add_segment();
+    stable_vector( std::initializer_list<T> init = {}) {
+        add_segment( init);
     }
 
     auto empty() const -> bool {
@@ -1348,11 +1357,16 @@ class timer
     }
 };
 
-static std::map<std::string, timer> timers;     // global named timers
+static std::unordered_map<std::string_view, timer> timers;  // global named timers
 
-auto scope_timer(std::string const& name) {
-    timers[name].start();
-    return finally( [=]{ timers[name].stop(); } );
+auto scope_timer(std::string_view name) -> std::shared_ptr<void> {
+    if (flag_internal_debug) {
+        timers[name].start();
+        auto stop = [=]{ timers[name].stop(); };
+        return std::make_shared<finally<decltype(stop)>>( std::move(stop) );
+    }
+    //  Else
+    return {};
 }
 
 

Diff for: source/cppfront.cpp

@@ -115,11 +115,16 @@ auto main(
                     auto total_time = print_with_thousands(t.elapsed().count());
                     std::cout << "\n   Time  " << total_time << " ms";
 
+                    std::multimap< long long, std::string_view, std::greater<long long> > sorted_timers;
                     for (auto [name, t] : timers) {
+                        sorted_timers.insert({t.elapsed().count(), name});
+                    }
+
+                    for (auto [elapsed, name] : sorted_timers) {
                         std::cout
                             << "\n         "
                             << std::right << std::setw(total_time.size())
-                            << print_with_thousands(t.elapsed().count()) << " ms" << " in " << name;
+                            << print_with_thousands(elapsed) << " ms" << " in " << name;
                     }
                 }
 

Diff for: source/lex.h

@@ -21,7 +21,6 @@
 #include "io.h"
 #include <map>
 #include <climits>
-#include <deque>
 #include <cstring>
 
 
@@ -614,11 +613,11 @@ auto expand_raw_string_literal(
 //  A stable place to store additional text for source tokens that are merged
 //  into a whitespace-containing token (to merge the Cpp1 multi-token keywords)
 //  -- this isn't about tokens generated later, that's tokens::generated_tokens
-static auto generated_text  = std::deque<std::string>{};                // TODO: static
-static auto generated_lines = std::deque<std::vector<source_line>>{};   // TODO: static
+static auto generated_text  = stable_vector<std::string>{};                // TODO: static
+static auto generated_lines = stable_vector<std::vector<source_line>>{};   // TODO: static
 
 
-static auto multiline_raw_strings = std::deque<multiline_raw_string>{}; // TODO: static
+static auto multiline_raw_strings = stable_vector<multiline_raw_string>{}; // TODO: static
 
 auto lex_line(
     std::string&               mutable_line,
@@ -1885,7 +1884,7 @@ class tokens
     std::vector<comment> comments;
 
     //  A stable place to store additional tokens that are synthesized later
-    std::deque<token> generated_tokens;
+    stable_vector<token> generated_tokens;
 
 public:
     //-----------------------------------------------------------------------
@@ -2070,7 +2069,7 @@ class tokens
 
 };
 
-static auto generated_lexers = std::deque<tokens>{};    // TODO: static
+static auto generated_lexers = stable_vector<tokens>{};    // TODO: static
 
 }
 

Diff for: source/parse.h

@@ -5331,7 +5331,7 @@ class parser
     };
 
     std::vector<token> const* tokens = {};
-    std::deque<token>* generated_tokens = {};
+    stable_vector<token>*     generated_tokens = {};
     int pos = 0;
     std::string parse_kind = {};
 
@@ -5430,8 +5430,8 @@ class parser
     //  sections in a TU to build the whole TU's parse tree
     //
     auto parse(
-        std::vector<token> const& tokens_,
-        std::deque<token>&        generated_tokens_
+        std::vector<token> const&  tokens_,
+        stable_vector<token>&      generated_tokens_
     )
         -> bool
     {
@@ -5469,7 +5469,7 @@ class parser
     //
     auto parse_one_declaration(
         std::vector<token> const& tokens_,
-        std::deque<token>&        generated_tokens_
+        stable_vector<token>&     generated_tokens_
     )
         -> std::unique_ptr<statement_node>
     {

Diff for: source/reflect.h

@@ -86,7 +86,7 @@ class compiler_services
     //
     private: std::vector<error_entry>* errors; 
     private: int errors_original_size; 
-    private: std::deque<token>* generated_tokens; 
+    private: stable_vector<token>* generated_tokens; 
     private: cpp2::parser parser; 
     private: std::string metafunction_name {}; 
     private: std::vector<std::string> metafunction_args {}; 
@@ -97,7 +97,7 @@ class compiler_services
     public: explicit compiler_services(
 
         std::vector<error_entry>* errors_, 
-        std::deque<token>* generated_tokens_
+        stable_vector<token>* generated_tokens_
     );
 
 #line 58 "reflect.h2"
@@ -790,7 +790,7 @@ namespace meta {
     compiler_services::compiler_services(
 
         std::vector<error_entry>* errors_, 
-        std::deque<token>* generated_tokens_
+        stable_vector<token>* generated_tokens_
     )
         : errors{ errors_ }
         , errors_original_size{ cpp2::unsafe_narrow<int>(std::ssize(*cpp2::impl::assert_not_null(errors))) }

Diff for: source/reflect.h2

@@ -35,7 +35,7 @@ compiler_services: @polymorphic_base @copyable type =
     //
     errors               : *std::vector<error_entry>;
     errors_original_size : int;
-    generated_tokens     : *std::deque<token>;
+    generated_tokens     : *stable_vector<token>;
     parser               : cpp2::parser;
     metafunction_name    : std::string = ();
     metafunction_args    : std::vector<std::string> = ();
@@ -46,7 +46,7 @@ compiler_services: @polymorphic_base @copyable type =
     operator=: (
         out this,
         errors_          : *std::vector<error_entry>,
-        generated_tokens_: *std::deque<token>
+        generated_tokens_: *stable_vector<token>
     )
     = {
         errors = errors_;

Diff for: source/sema.h

@@ -481,6 +481,8 @@ class sema
         }
         //--------- END TEMPORARY REGRESSION TEST CODE FOR G_D_O OPTIMIZATION VERIFICATION -----------
 
+        auto timer = scope_timer("get_declaration_of_new - including external caching");
+
         //  Check the cache first to avoid duplicate computations
         //
         auto my_params = gdo_params{&t, look_beyond_current_function, include_implicit_this};
@@ -748,11 +750,15 @@ class sema
     ) const
         -> declaration_sym const*
     {
-        auto timer  = scope_timer("get_declaration_of_new");
+        auto timer = scope_timer("get_declaration_of_new");
 
         //  First find the position the query is coming from
         //  and remember its depth
         auto i = symbols.cbegin();
+        auto depth = 0;
+
+        {
+        auto timer1 = scope_timer("get_declaration_of_new - phase 1 initial loop");
 
         //  If the declaration_starts list got this far yet, use that to
         //  skip repeating the whole linear search from the table beginning
@@ -805,8 +811,6 @@ class sema
 
         initial_find_new = i;
 
-        auto depth = 0;
-
         //  If we found it exactly, we have its depth
         if (
             i != symbols.cend()
@@ -881,17 +885,22 @@ class sema
 
             depth = i->depth;
         }
+        }
+
+        auto timer2 = scope_timer("get_declaration_of_new - phase 2 backward scan loop");
 
         //  Then look backward to find the first declaration of
         //  this name that is not deeper (in a nested scope)
         //  and is in the same function
         using I = stable_vector<symbol>::const_iterator;
         auto advance = [](I& i, int n, I bound) {  // TODO Use `std::ranges::advance`
+            auto timer2a = scope_timer("get_declaration_of_new - phase 2a 'advance' part of loop");
             auto in = i;
             if (std::abs(n) >= std::abs(bound - i)) {
                 i = bound;
             }
             else {
+                auto timer2aa = scope_timer("get_declaration_of_new - phase 2aa 'std::advance' specifically");
                 std::advance(i, n);
             }
             return n - (i - in);
@@ -933,6 +942,8 @@ class sema
                     return &decl;
                 }
 
+                auto timer2b = scope_timer("get_declaration_of_new - phase 2b 'move this' part of loop");
+
                 //  If we reached a 'move this' parameter, look it up in the type members
                 if (
                     include_implicit_this

Diff for: source/to_cpp1.h

@@ -164,14 +164,6 @@ static cmdline_processor::register_flag cmd_cpp1_filename(
     [](std::string const& name) { flag_cpp1_filename = name; }
 );
 
-static auto flag_verbose = false;
-static cmdline_processor::register_flag cmd_verbose(
-    9,
-    "verbose",
-    "Print verbose output and statistics",
-    []{ flag_verbose = true; }
-);
-
 static auto flag_no_exceptions = false;
 static cmdline_processor::register_flag cmd_no_exceptions(
     4,
@@ -1087,7 +1079,7 @@ class cppfront
     };
     class current_functions_
     {
-        std::deque<function_info> list = { {} };
+        stable_vector<function_info> list = { {} };
     public:
         auto push(
             declaration_node const*                    decl,