Changeset c15085d

Timestamp:

Jul 3, 2020, 4:50:21 PM (3 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

aebf5b0

Parents:

276f105

Message:

tracing memory allocation of resolver passes

Location:

src

Files:

• AST/Pass.impl.hpp (modified) (2 diffs)
• AST/Pass.proto.hpp (modified) (2 diffs)
• AST/TypeSubstitution.cpp (modified) (1 diff)
• AST/TypeSubstitution.hpp (modified) (1 diff)
• Common/Stats/Heap.cc (modified) (6 diffs)
• Common/Stats/Heap.h (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/Unify.cc (modified) (2 diffs)

src/AST/Pass.impl.hpp

@@ -28 +28 @@
         /* setup the scope for passes that want to run code at exit */ \
         __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (pass, 0) ); \
+        /* begin tracing memory allocation if requested by this pass */ \
+        __pass::beginTrace( pass, 0 ); \
         /* call the implementation of the previsit of this pass */ \
         __pass::previsit( pass, node, 0 );
@@ -42 +44 @@
         auto __return = __pass::postvisit( pass, node, 0 ); \
         assertf(__return, "post visit should never return null"); \
+        /* end tracing memory allocation if requested by this pass */ \
+        __pass::endTrace( pass, 0 ); \
         return __return;
 

src/AST/Pass.proto.hpp

@@ -16 +16 @@
 #pragma once
 // IWYU pragma: private, include "Pass.hpp"
+
+#include "Common/Stats/Heap.h"
 
 namespace ast {
@@ -244 +246 @@
         #undef FIELD_PTR
 
+        template< typename pass_t >
+        static inline auto beginTrace(pass_t & pass, int) -> decltype( pass_t::traceId, void() ) {
+                Stats::Heap::stacktrace_push(pass_t::traceId);
+        }
+
+        template< typename pass_t > 
+        static inline auto endTrace(pass_t & pass, int) -> decltype( pass_t::traceId, void() ) {
+                Stats::Heap::stacktrace_pop();
+        }
+
+        template< typename pass_t >
+        static void beginTrace(pass_t &, long) {}
+
+        template< typename pass_t >
+        static void endTrace(pass_t &, long) {}
+
         // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
         // All passes which have such functions are assumed desire this behaviour

src/AST/TypeSubstitution.cpp

@@ -18 +18 @@
 
 namespace ast {
+
+
+size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
 
 TypeSubstitution::TypeSubstitution() {

src/AST/TypeSubstitution.hpp

@@ -160 +160 @@
 // definitition must happen after PassVisitor is included so that WithGuards can be used
 struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
+                static size_t traceId;
 
                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}

src/Common/Stats/Heap.cc

@@ -53 +53 @@
                 const size_t passes_size = sizeof(passes) / sizeof(passes[0]);
                 size_t       passes_cnt = 1;
+
+                StatBlock    stacktrace_stats[100];
+                size_t       stacktrace_stats_count = 0;
+                bool         stacktrace_stats_enabled = true;
+
+                size_t       trace[1000];
+                const size_t stacktrace_max_depth = sizeof(trace) / sizeof(size_t);
+                size_t       stacktrace_depth;
+
+                size_t new_stacktrace_id(const char * const name) {
+                        stacktrace_stats[stacktrace_stats_count].name = name;
+                        return stacktrace_stats_count++;
+                }
+
+                void stacktrace_push(size_t id) {
+                        ++stacktrace_depth;
+                        assertf(stacktrace_depth < stacktrace_max_depth, "Stack trace too deep: increase size of array in Heap.cc");
+                        trace[stacktrace_depth] = id;
+                }
+
+                void stacktrace_pop() {
+                        assertf(stacktrace_depth > 0, "Invalid stack tracing operation: trace is empty");
+                        --stacktrace_depth;
+                }
 
                 void newPass( const char * const name ) {
@@ -116 +140 @@
                         for(size_t i = 0; i < passes_cnt; i++) {
                                 print(passes[i], nc, total_mallocs, total_frees, overall_peak);
+                        }
+
+                        print('-', nct);
+                        std::cerr << std::setw(nc) << "Trace";
+                        std::cerr << " |       Malloc Count |         Free Count |        Peak Allocs |" << std::endl;
+
+                        print('-', nct);
+                        for (size_t i = 0; i < stacktrace_stats_count; i++) {
+                                print(stacktrace_stats[i], nc, total_mallocs, total_frees, overall_peak);
                         }
                         print('-', nct);
@@ -188 +221 @@
                                                 = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs);
                                 }
+
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].mallocs++;
+                                }
                                 return __malloc( size );
                         }
@@ -196 +233 @@
                                         passes[passes_cnt - 1].frees++;
                                         passes[passes_cnt - 1].n_allocs--;
+                                }
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].frees++;
                                 }
                                 return __free( ptr );
@@ -208 +248 @@
                                                 = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs);
                                 }
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].mallocs++;
+                                }
                                 return __calloc( nelem, size );
                         }
@@ -218 +261 @@
                                         passes[passes_cnt - 1].frees++;
                                 } // if
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].mallocs++;
+                                        stacktrace_stats[trace[stacktrace_depth]].frees++;
+                                }
                                 return s;
                         }

src/Common/Stats/Heap.h

@@ -20 +20 @@
                 void newPass( const char * const name );
                 void print();
+
+                size_t new_stacktrace_id(const char * const name);
+                void stacktrace_push(size_t id);
+                void stacktrace_pop();
         }
 }

src/ResolvExpr/CandidateFinder.cpp

@@ -596 +596 @@
                 const ast::SymbolTable & symtab;
         public:
+                static size_t traceId;
                 CandidateFinder & selfFinder;
                 CandidateList & candidates;
@@ -1507 +1508 @@
         };
 
+        size_t Finder::traceId = Stats::Heap::new_stacktrace_id("Finder");
         /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
         /// return type. Skips ambiguous candidates.

src/ResolvExpr/CommonType.cc

@@ -666 +666 @@
                 const ast::OpenVarSet & open;
         public:
+                static size_t traceId;
                 ast::ptr< ast::Type > result;
 
@@ -893 +894 @@
         };
 
+        size_t CommonType_new::traceId = Stats::Heap::new_stacktrace_id("CommonType_new");
         namespace {
                 ast::ptr< ast::Type > handleReference(

src/ResolvExpr/ConversionCost.cc

@@ -795 +795 @@
         }
 }
-
+size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
 
 } // namespace ResolvExpr

src/ResolvExpr/ConversionCost.h

@@ -88 +88 @@
         CostCalculation costCalc;
 public:
+        static size_t traceId;
         Cost cost;
 

src/ResolvExpr/Resolver.cc

@@ -1236 +1236 @@
 
         public:
+                static size_t traceId;
                 Resolver_new() = default;
                 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
@@ -1266 +1267 @@
                 const ast::ConstructorInit * previsit( const ast::ConstructorInit * );
         };
+        size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
 
         void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) {

src/ResolvExpr/Unify.cc

@@ -702 +702 @@
                 const ast::SymbolTable & symtab;
         public:
+                static size_t traceId;
                 bool result;
 
@@ -1135 +1136 @@
         };
 
+        size_t Unify_new::traceId = Stats::Heap::new_stacktrace_id("Unify_new");
         bool unify(
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,