Changeset c884f2d

Timestamp:

Mar 5, 2019, 3:08:46 PM (5 years ago)

Author:

tdelisle <tdelisle@…>

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:

972540e

Parents:

3c0d4cd

Message:

Fixed error for % of parent printing in timing sections and added more timing instrumentation

Location:

src

Files:

• Common/Stats/Time.cc (modified) (1 diff)
• Common/Stats/Time.h (modified) (2 diffs)
• SymTab/Validate.cc (modified) (2 diffs)

src/Common/Stats/Time.cc

@@ -88 +88 @@
                                 virtual void print(std::ostream & os) override {
                                         if(currl > prevl) {
+                                                // std::cerr << "push last " << last << std::endl;
                                                 parents.push(last);
                                         } else if(currl < prevl) {
                                                 parents.pop();
-                                        } else {
+                                                // std::cerr << "pop, top = " << parents.top() << std::endl;
+                                        }
+                                        // else {
                                                 last = end - begin;
-                                        }
+                                                // std::cerr << "last = " << last << "\t";
+                                        // }
 
                                         assert(finished);

src/Common/Stats/Time.h

@@ -38 +38 @@
 
                         template<typename func_t>
-                        inline void TimeBLock(const char *, func_t) {}
+                        inline void TimeBlock(const char *, func_t f) {
+                                f();
+                        }
 #               else
                         void StartGlobal();
@@ -53 +55 @@
 
                         template<typename func_t>
-                        inline void TimeBLock(const char * name, func_t func) {
+                        inline void TimeBlock(const char * name, func_t func) {
                                 BlockGuard guard(name);
                                 func();

src/SymTab/Validate.cc

@@ -315 +315 @@
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("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::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 ); //
+                        });
                 }
                 {
@@ -331 +339 @@
                         Stats::Heap::newPass("validate-D");
                         Stats::Time::BlockGuard guard("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::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");
-                        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::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");
-                        FixObjectType::fix( translationUnit );
-                        ArrayLength::computeLength( translationUnit );
-                        acceptAll( translationUnit, finder ); // xxx - remove this pass soon
-                        mutateAll( translationUnit, labelAddrFixer );
-                        Validate::handleAttributes( translationUnit );
+                        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 );
+                        });
                 }
         }