Changeset b38433b for src/SymTab

Timestamp:

Mar 5, 2019, 6:17:55 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

b830e046, c101756

Parents:

34737de (diff), 972540e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/SymTab

Files:

• Indexer.cc (modified) (7 diffs)
• Validate.cc (modified) (1 diff)

src/SymTab/Indexer.cc

@@ -45 +45 @@
         // Statistics block
         namespace {
-                auto idtable_group = new Stats::Counters::CounterGroup("IdTable");
-                auto idtable_find  = new Stats::Counters::SimpleCounter("Find calls", idtable_group);
-                auto idtable_size  = new Stats::Counters::AverageCounter<double>("Average Size", idtable_group);
-                auto idtable_key   = new Stats::Counters::AverageCounter<double>("Average Key Size", idtable_group);
-
-                auto indexers_group = new Stats::Counters::CounterGroup("Indexers");
-                auto indexers_count = new Stats::Counters::SimpleCounter("Count", indexers_group);
-                auto indexers_size  = new Stats::Counters::AverageCounter<double>("Average Size", indexers_group);
-                auto indexers_depth_a  = new Stats::Counters::AverageCounter<double>("Average Depth", indexers_group);
-                auto indexers_depth_m  = new Stats::Counters::MaxCounter<size_t>("Max Depth", indexers_group);
+
+                static inline auto stats_idtable() {
+                        using namespace Stats::Counters;
+                        static auto group = build<CounterGroup>("IdTable");
+                        static struct {
+                                SimpleCounter * find;
+                                AverageCounter<double> * size;
+                                AverageCounter<double> * key;
+                        } ret = {
+                                .find = build<SimpleCounter>("Find calls", group),
+                                .size = build<AverageCounter<double>>("Average Size", group),
+                                .key  = build<AverageCounter<double>>("Average Key Size", group),
+                        };
+                        return ret;
+                }
+
+                static inline auto stats_indexers() {
+                        using namespace Stats::Counters;
+                        static auto group   = build<CounterGroup>("Indexers");
+                        static struct {
+                                SimpleCounter * count;
+                                AverageCounter<double> * size;
+                                AverageCounter<double> * depth_a;
+                                MaxCounter<size_t> * depth_m;
+                        } ret = {
+                                .count   = build<SimpleCounter>("Count", group),
+                                .size    = build<AverageCounter<double>>("Average Size", group),
+                                .depth_a = build<AverageCounter<double>>("Average Depth", group),
+                                .depth_m = build<MaxCounter<size_t>>("Max Depth", group),
+                        };
+                        return ret;
+                }
         }
 
@@ -214 +236 @@
 
         Indexer::Indexer() : tables( 0 ), scope( 0 ) {
-                (*indexers_count)++;
+                (*stats_indexers().count)++;
         }
 
         Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {
-                (*indexers_count)++;
+                (*stats_indexers().count)++;
         }
 
@@ -227 +249 @@
         Indexer::~Indexer() {
                 if(tables) {
-                        indexers_size->push( tables->idTable.size() );
+                        stats_indexers().size->push( tables->idTable.size() );
                         size_t depth = 1;
                         for( auto crnt = tables->base.tables; crnt; crnt = crnt->base.tables ) {
                                 ++depth;
                         }
-                        indexers_depth_a->push( depth );
-                        indexers_depth_m->push( depth );
+                        stats_indexers().depth_a->push( depth );
+                        stats_indexers().depth_m->push( depth );
                 }
                 deleteRef( tables );
@@ -266 +288 @@
                 while ( searchTables ) {
 
-                        (*idtable_find)++;
-                        idtable_key->push( id.size() );
-                        idtable_size->push( searchTables->idTable.size() );
+                        (*stats_idtable().find)++;
+                        stats_idtable().key->push( id.size() );
+                        stats_idtable().size->push( searchTables->idTable.size() );
                         IdTable::const_iterator decls = searchTables->idTable.find( id );
                         if ( decls != searchTables->idTable.end() ) {
@@ -345 +367 @@
                 if ( tables->scope < scope ) return nullptr;
 
-                (*idtable_find)++;
-                idtable_key->push( id.size() );
-                idtable_size->push( tables->idTable.size() );
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {
@@ -366 +388 @@
                 if ( tables->scope < scope ) return false;
 
-                (*idtable_find)++;
-                idtable_key->push( id.size() );
-                idtable_size->push( tables->idTable.size() );
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {
@@ -385 +407 @@
                 if ( tables->scope < scope ) return false;
 
-                (*idtable_find)++;
-                idtable_key->push( id.size() );
-                idtable_size->push( tables->idTable.size() );
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
                 IdTable::const_iterator decls = tables->idTable.find( id );
                 if ( decls != tables->idTable.end() ) {

src/SymTab/Validate.cc

@@ -304 +304 @@
                 PassVisitor<FixQualifiedTypes> fixQual;
 
-                Stats::Heap::newPass("validate-A");
-                acceptAll( translationUnit, hoistDecls );
-                ReplaceTypedef::replaceTypedef( translationUnit );
-                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
-                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
-                Stats::Heap::newPass("validate-B");
-                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
-                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
-                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
-                EliminateTypedef::eliminateTypedef( translationUnit ); //
-                Stats::Heap::newPass("validate-C");
-                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
-                VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
-                ReturnChecker::checkFunctionReturns( translationUnit );
-                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
-                Stats::Heap::newPass("validate-D");
-                Concurrency::applyKeywords( translationUnit );
-                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
-                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
-                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
-                Stats::Heap::newPass("validate-E");
-                Concurrency::implementMutexFuncs( translationUnit );
-                Concurrency::implementThreadStarter( translationUnit );
-                mutateAll( translationUnit, compoundliteral );
-                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
-                Stats::Heap::newPass("validate-F");
-                FixObjectType::fix( translationUnit );
-                ArrayLength::computeLength( translationUnit );
-                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
-                mutateAll( translationUnit, labelAddrFixer );
-                Validate::handleAttributes( translationUnit );
+                {
+                        Stats::Heap::newPass("validate-A");
+                        Stats::Time::BlockGuard guard("validate-A");
+                        acceptAll( translationUnit, hoistDecls );
+                        ReplaceTypedef::replaceTypedef( translationUnit );
+                        ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                        acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
+                }
+                {
+                        Stats::Heap::newPass("validate-B");
+                        Stats::Time::BlockGuard guard("validate-B");
+                        Stats::Time::TimeBlock("Link Reference To Types", [&]() {
+                                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        });
+                        Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
+                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
+                        });
+                        Stats::Time::TimeBlock("Hoist Structs", [&]() {
+                                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
+                        });
+                        Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
+                                EliminateTypedef::eliminateTypedef( translationUnit ); //
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-C");
+                        Stats::Time::BlockGuard guard("validate-C");
+                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
+                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                        ReturnChecker::checkFunctionReturns( translationUnit );
+                        InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                }
+                {
+                        Stats::Heap::newPass("validate-D");
+                        Stats::Time::BlockGuard guard("validate-D");
+                        Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
+                                Concurrency::applyKeywords( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
+                                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
+                        });
+                        Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
+                                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
+                        });
+                        Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
+                                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-E");
+                        Stats::Time::BlockGuard guard("validate-E");
+                        Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
+                                Concurrency::implementMutexFuncs( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Implement Thread Start", [&]() {
+                                Concurrency::implementThreadStarter( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Compound Literal", [&]() {
+                                mutateAll( translationUnit, compoundliteral );
+                        });
+                        Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
+                                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-F");
+                        Stats::Time::BlockGuard guard("validate-F");
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
+                        });
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
+                }
         }