Changeset f923b5f


Ignore:
Timestamp:
Feb 8, 2017, 3:18:44 PM (5 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
d3a804f5
Parents:
ea23d10
Message:

Added stats on types used to DeclStats?

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/CodeTools/DeclStats.cc

    rea23d10 rf923b5f  
    1818#include <iostream>
    1919#include <map>
     20#include <sstream>
    2021#include <string>
    2122#include <unordered_map>
     
    7172                                return *this;
    7273                        }
    73 
    74                         /// Update based on a declaration list
    75                         ArgPackStats& operator+= ( std::list<DeclarationWithType*>& decls ) {
    76                                 unsigned nn = 0;
    77                                 unsigned nn_basic = 0;
    78                                 unsigned nn_poly = 0;
    79                                 for ( auto decl : decls ) {
    80                                         nn += decl->get_type()->size();
    81                                         if ( dynamic_cast<BasicType*>( decl->get_type() ) ) ++nn_basic;
    82                                         else if ( GenPoly::hasPolyBase( decl->get_type() ) ) ++nn_poly;
    83                                 }
    84                                 ++n.at( nn );
    85                                 ++n_basic.at( nn_basic );
    86                                 ++n_poly.at( nn_poly );
    87                                 if ( nn > 0 ) {
    88                                         ++p_basic[ nn_basic*100/nn ];
    89                                         ++p_poly[ nn_poly*100/nn ];
    90                                 }
    91                                
    92                                 return *this;
    93                         }
    9474                };
    9575               
     
    10080                        /// Count of declarations with each name
    10181                        std::unordered_map<std::string, unsigned> by_name;
     82                        /// Count of uses of each basic type
     83                        std::unordered_map<std::string, unsigned> basic_type_names;
     84                        /// Count of uses of each non-basic type
     85                        std::unordered_map<std::string, unsigned> compound_type_names;
    10286                        /// Stats for the parameter list
    10387                        ArgPackStats params;
     
    11296                        ArgPackStats assn_returns;
    11397                       
    114                         Stats() : n_decls(0), n_type_params(), by_name(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
     98                        Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
    11599
    116100                public:
     
    119103                                sum( n_type_params, o.n_type_params );
    120104                                sum( by_name, o.by_name );
     105                                sum( basic_type_names, o.basic_type_names );
     106                                sum( compound_type_names, o.compound_type_names );
    121107                                sum( params, o.params );
    122108                                sum( returns, o.returns );
     
    133119                Stats total;
    134120
    135                 void analyzeFunc( FunctionType* fnTy, ArgPackStats& params, ArgPackStats& returns ) {
    136                         params += fnTy->get_parameters();
    137                         returns += fnTy->get_returnVals();
     121                /// Update arg pack stats based on a declaration list
     122                void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
     123                        unsigned n = 0;
     124                        unsigned n_basic = 0;
     125                        unsigned n_poly = 0;
     126                        for ( auto decl : decls ) {
     127                                n += decl->get_type()->size();
     128                                if ( BasicType* bt = dynamic_cast<BasicType*>( decl->get_type() ) ) {
     129                                        ++n_basic;
     130                                        std::stringstream ss;
     131                                        bt->print( ss );
     132                                        ++stats.basic_type_names[ ss.str() ];
     133                                } else if ( GenPoly::hasPolyBase( decl->get_type() ) ) {
     134                                        ++n_poly;
     135                                } else {
     136                                        std::stringstream ss;
     137                                        decl->get_type()->print( ss );
     138                                        ++stats.compound_type_names[ ss.str() ];
     139                                }
     140                        }
     141                        ++pstats.n.at( n );
     142                        ++pstats.n_basic.at( n_basic );
     143                        ++pstats.n_poly.at( n_poly );
     144                        if ( n > 0 ) {
     145                                ++pstats.p_basic[ n_basic*100/n ];
     146                                ++pstats.p_poly[ n_poly*100/n ];
     147                        }
     148                }
     149               
     150                void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
     151                        analyze( stats, params, fnTy->get_parameters() );
     152                        analyze( stats, returns, fnTy->get_returnVals() );
    138153                }
    139154
     
    164179                                                assnTy = assnDecl->get_functionType();
    165180                                        }
    166                                         if ( assnTy ) analyzeFunc( assnTy, stats.assn_params, stats.assn_returns );
     181                                        if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
    167182                                }
    168183                        }
     
    171186                        ++stats.by_name[ decl->get_name() ];
    172187
    173                         analyzeFunc( fnTy, stats.params, stats.returns );
     188                        analyzeFunc( fnTy, stats, stats.params, stats.returns );
    174189                }
    175190
     
    266281                        printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); });
    267282                        printAllSparseHisto("overloads", [](const Stats& stats) { return stats.by_name; });
     283                        printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); });
     284                        printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
    268285                        printAllPack("params", [](const Stats& stats) { return stats.params; });
    269286                        printAllPack("returns", [](const Stats& stats) { return stats.returns; });
Note: See TracChangeset for help on using the changeset viewer.