Changes in / [e23d20b:b04a408]
- File:
-
- 1 edited
-
src/CodeTools/DeclStats.cc (modified) (19 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/CodeTools/DeclStats.cc
re23d20b rb04a408 62 62 63 63 struct ArgPackStats { 64 VectorMap<unsigned> n; ///< Count of decls with each number of elements 65 VectorMap<unsigned> n_basic; ///< Count of decls with each number of basic type elements 66 VectorMap<unsigned> n_generic; ///< Count of decls with each number of generic type elements 67 VectorMap<unsigned> n_poly; ///< Count of decls with each number of polymorphic elements 68 VectorMap<unsigned> n_compound; ///< Count of decls with each number of non-generic compound types 69 std::map<unsigned, unsigned> p_basic; ///< Count of decls with each percentage of basic type elements 70 std::map<unsigned, unsigned> p_generic; ///< Count of decls with each percentage of generic type elements 71 std::map<unsigned, unsigned> p_poly; ///< Count of decls with each percentage of polymorphic elements 72 std::map<unsigned, unsigned> p_compound; ///< Count of decls with each percentage of non-generic compound type elements 73 VectorMap<unsigned> n_types; ///< Count of decls with each number of distinct types in the pack 64 VectorMap<unsigned> n; ///< Count of decls with each number of elements 65 VectorMap<unsigned> n_basic; ///< Count of decls with each number of basic type elements 66 VectorMap<unsigned> n_poly; ///< Count of decls with each number of polymorphic elements 67 std::map<unsigned, unsigned> p_basic; ///< Count of decls with each percentage of basic type elements 68 std::map<unsigned, unsigned> p_poly; ///< Count of decls with each percentage of polymorphic elements 69 VectorMap<unsigned> n_types; ///< Count of decls with each number of distinct types in the pack 74 70 /// Count of decls with each percentage of new types in lists. 75 71 /// Types used in the parameter list that recur in the return list are not considered to be new. … … 79 75 sum(n, o.n); 80 76 sum(n_basic, o.n_basic); 81 sum(n_generic, o.n_generic);82 77 sum(n_poly, o.n_poly); 83 sum(n_compound, o.n_compound);84 78 sum(p_basic, o.p_basic); 85 sum(p_generic, o.p_generic);86 79 sum(p_poly, o.p_poly); 87 sum(p_compound, o.p_compound);88 80 sum(n_types, o.n_types); 89 81 sum(p_new, o.p_new); … … 97 89 /// Count of declarations with each number of assertion parameters 98 90 VectorMap<unsigned> n_type_params; 99 /// Count of generic types with each number of type parameters100 VectorMap<unsigned> n_generic_params;101 /// Count of maximum nesting depth of types102 VectorMap<unsigned> n_generic_nesting;103 91 /// Count of declarations with each name 104 92 std::unordered_map<std::string, unsigned> by_name; 105 93 /// Count of uses of each basic type 106 94 std::unordered_map<std::string, unsigned> basic_type_names; 107 /// Count of uses of each generic type name (includes "*", "[]", "(*)", "[,]") 108 std::unordered_map<std::string, unsigned> generic_type_names; 109 /// Count of uses of each non-generic aggregate type 95 /// Count of uses of each non-basic type 110 96 std::unordered_map<std::string, unsigned> compound_type_names; 111 97 /// Count of decls using each basic type 112 98 std::unordered_map<std::string, unsigned> basic_type_decls; 113 /// Count of decls using each generic type (includes "*", "[]", "(*)", "[,]")114 std::unordered_map<std::string, unsigned> generic_type_decls;115 99 /// Count of decls using each compound type 116 100 std::unordered_map<std::string, unsigned> compound_type_decls; … … 127 111 ArgPackStats assn_returns; 128 112 129 Stats() : n_decls(0), n_type_params(), n_generic_params(), n_generic_nesting(), 130 by_name(), basic_type_names(), generic_type_names(), compound_type_names(), 131 basic_type_decls(), generic_type_decls(), compound_type_decls(), params(), 132 returns(), n_assns(), assn_params(), assn_returns() {} 113 Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), basic_type_decls(), compound_type_decls(), params(), returns(), n_assns(), assn_params(), assn_returns() {} 133 114 134 115 public: … … 136 117 sum( n_decls, o.n_decls ); 137 118 sum( n_type_params, o.n_type_params ); 138 sum( n_generic_params, o.n_generic_params );139 sum( n_generic_nesting, o.n_generic_nesting );140 119 sum( by_name, o.by_name ); 141 120 sum( basic_type_names, o.basic_type_names ); 142 sum( generic_type_names, o.generic_type_names );143 121 sum( compound_type_names, o.compound_type_names ); 144 122 sum( basic_type_decls, o.basic_type_decls ); 145 sum( generic_type_decls, o.generic_type_decls );146 123 sum( compound_type_decls, o.compound_type_decls ); 147 124 sum( params, o.params ); … … 155 132 }; 156 133 157 /// number of counting bins for linkages 158 static const unsigned n_named_specs = 8; 159 /// map from total number of specs to bins 160 static const unsigned ind_for_linkage[16]; 161 162 Stats for_linkage[n_named_specs]; ///< Stores separate stats per linkage 134 Stats for_linkage[LinkageSpec::NoOfSpecs]; ///< Stores separate stats per linkage 163 135 std::unordered_set<std::string> seen_names; ///< Stores manglenames already seen to avoid double-counting 164 136 Stats total; … … 166 138 std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth; 167 139 168 void countType( const std::string& name, unsigned& n, std::unordered_map<std::string,169 unsigned>& names, std::unordered_map<std::string, unsigned>& decls,170 std::unordered_set<std::string>& elSeen ) {171 ++n;172 ++names[ name ];173 if ( elSeen.insert( name ).second ) { ++decls[ name ]; }174 }175 176 void update_max( unsigned& max, unsigned crnt ) {177 if ( crnt > max ) max = crnt;178 }179 180 void analyzeSubtype( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen,181 unsigned& n_poly, bool& seen_poly, unsigned& max_depth, unsigned depth ) {182 unsigned x;183 analyzeType( ty, stats, elSeen, x, x, n_poly, x, seen_poly, max_depth, depth + 1 );184 }185 186 void analyzeSubtypes( std::list<DeclarationWithType*>& tys, Stats& stats,187 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,188 unsigned& max_depth, unsigned depth, unsigned& n_subs ) {189 for ( DeclarationWithType* dwt : tys ) {190 Type* ty = dwt->get_type();191 n_subs += (unsigned)( dynamic_cast<VoidType*>(ty) != nullptr );192 analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth );193 }194 }195 196 void analyzeSubtypes( std::list<Expression*>& tys, Stats& stats,197 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,198 unsigned& max_depth, unsigned depth ) {199 for ( Expression* expr : tys ) {200 TypeExpr* texpr = dynamic_cast<TypeExpr*>(expr);201 if ( ! texpr ) continue;202 Type* ty = texpr->get_type();203 analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth );204 }205 }206 207 void analyzeSubtypes( std::list<Type*>& tys, Stats& stats,208 std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,209 unsigned& max_depth, unsigned depth ) {210 for ( Type* ty : tys ) {211 analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth );212 }213 }214 215 void analyzeType( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen,216 unsigned& n_basic, unsigned& n_generic, unsigned& n_poly, unsigned& n_agg,217 bool& seen_poly, unsigned& max_depth, unsigned depth = 0 ) {218 if ( BasicType* bt = dynamic_cast<BasicType*>(ty) ) {219 std::string name = BasicType::typeNames[ bt->get_kind() ];220 countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen );221 update_max( max_depth, depth );222 } else if ( PointerType* pt = dynamic_cast<PointerType*>(ty) ) {223 std::string name = "*";224 countType(225 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);226 analyzeSubtype(227 pt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );228 ++stats.n_generic_params.at( 1 );229 } else if ( ArrayType* at = dynamic_cast<ArrayType*>(ty) ) {230 std::string name = "[]";231 countType(232 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);233 analyzeSubtype(234 at->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );235 ++stats.n_generic_params.at( 1 );236 } else if ( ReferenceType* rt = dynamic_cast<ReferenceType*>(ty) ) {237 std::string name = "&";238 countType(239 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);240 analyzeSubtype(241 rt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );242 ++stats.n_generic_params.at( 1 );243 } else if ( FunctionType* ft = dynamic_cast<FunctionType*>(ty) ) {244 std::string name = "(*)";245 countType(246 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);247 unsigned n_subs = 0;248 analyzeSubtypes(249 ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth,250 n_subs );251 analyzeSubtypes(252 ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth,253 n_subs );254 ++stats.n_generic_params.at( n_subs );255 } else if ( TypeInstType* vt = dynamic_cast<TypeInstType*>(ty) ) {256 if ( ! seen_poly ) {257 ++n_poly;258 seen_poly = true;259 }260 countType(261 vt->get_name(), n_agg, stats.compound_type_names, stats.compound_type_decls,262 elSeen );263 update_max( max_depth, depth );264 } else if ( ReferenceToType* st = dynamic_cast<ReferenceToType*>(ty) ) {265 std::list<Expression*>& params = st->get_parameters();266 if ( params.empty() ) {267 countType(268 st->get_name(), n_agg, stats.compound_type_names,269 stats.compound_type_decls, elSeen );270 update_max( max_depth, depth );271 } else {272 countType(273 st->get_name(), n_generic, stats.generic_type_names,274 stats.generic_type_decls, elSeen);275 analyzeSubtypes( params, stats, elSeen, n_poly, seen_poly, max_depth, depth );276 ++stats.n_generic_params.at( params.size() );277 }278 } else if ( TupleType* tt = dynamic_cast<TupleType*>(ty) ) {279 std::string name = "[,]";280 countType(281 name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);282 analyzeSubtypes(283 tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth );284 ++stats.n_generic_params.at( tt->size() );285 } else if ( dynamic_cast<VarArgsType*>(ty) ) {286 std::string name = "...";287 countType(288 name, n_agg, stats.compound_type_names, stats.compound_type_decls, elSeen );289 update_max( max_depth, depth );290 } else if ( dynamic_cast<ZeroType*>(ty) ) {291 std::string name = "0";292 countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen );293 update_max( max_depth, depth );294 } else if ( dynamic_cast<OneType*>(ty) ) {295 std::string name = "1";296 countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen );297 update_max( max_depth, depth );298 }299 }300 301 140 /// Update arg pack stats based on a declaration list 302 void analyze( Stats& stats, std::unordered_set<std::string>& seen, 303 std::unordered_set<std::string>& elSeen, ArgPackStats& pstats, 304 std::list<DeclarationWithType*>& decls ) { 141 void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) { 305 142 std::unordered_set<std::string> types; 306 unsigned n = 0; ///< number of args/returns 307 unsigned n_basic = 0; ///< number of basic types 308 unsigned n_generic = 0; ///< number of generic types (includes "*", "&", "[]", "(*)", "[,]") 309 unsigned n_poly = 0; ///< number of polymorphic types 310 unsigned n_agg = 0; ///< number of non-generic aggregate types 311 unsigned n_new = 0; ///< number of new types 312 143 unsigned n = 0; ///< number of args/returns 144 unsigned n_basic = 0; ///< number of basic types 145 unsigned n_poly = 0; ///< number of polymorphic types 146 unsigned n_new = 0; ///< number of new types 313 147 for ( auto decl : decls ) { 314 148 Type* dt = decl->get_type(); … … 319 153 dt->print( ss ); 320 154 types.insert( ss.str() ); 321 if ( seen.insert( ss.str() ).second ) { ++n_new; } 322 323 bool seen_poly = false; 324 unsigned max_depth = 0; 325 analyzeType( 326 dt, stats, elSeen, n_basic, n_generic, n_poly, n_agg, seen_poly, max_depth ); 327 ++stats.n_generic_nesting.at( max_depth ); 328 } 329 155 bool this_new = seen.insert( ss.str() ).second; 156 if ( this_new ) { ++n_new; } 157 158 if ( dynamic_cast<BasicType*>( dt ) ) { 159 ++n_basic; 160 ++stats.basic_type_names[ ss.str() ]; 161 if ( this_new ) { 162 ++stats.basic_type_decls[ ss.str() ]; 163 } 164 } else if ( GenPoly::hasPolyBase( dt ) ) { 165 ++n_poly; 166 } else { 167 ++stats.compound_type_names[ ss.str() ]; 168 if ( this_new ) { 169 ++stats.compound_type_decls[ ss.str() ]; 170 } 171 } 172 } 330 173 ++pstats.n.at( n ); 331 174 ++pstats.n_basic.at( n_basic ); 332 ++pstats.n_generic.at( n_generic );333 175 ++pstats.n_poly.at( n_poly ); 334 ++pstats.n_compound.at( n_agg );335 176 if ( n > 0 ) { 336 177 ++pstats.p_basic[ n_basic*100/n ]; 337 ++pstats.p_generic[ n_generic*100/n ];338 178 ++pstats.p_poly[ n_poly*100/n ]; 339 ++pstats.p_compound[ n_agg*100/n ]; 340 if ( n > 1 ) ++pstats.p_new[ (n_new-1)*100/(n-1) ]; 179 ++pstats.p_new[ n_new*100/n ]; 341 180 } 342 181 ++pstats.n_types.at( types.size() ); … … 345 184 void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) { 346 185 std::unordered_set<std::string> seen; 347 std::unordered_set<std::string> elSeen; 348 analyze( stats, seen, elSeen, params, fnTy->get_parameters() ); 349 analyze( stats, seen, elSeen, returns, fnTy->get_returnVals() ); 186 analyze( stats, seen, params, fnTy->get_parameters() ); 187 analyze( stats, seen, returns, fnTy->get_returnVals() ); 350 188 } 351 189 … … 367 205 const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName(); 368 206 if ( seen_names.insert( mangleName ).second ) { 369 Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ]];207 Stats& stats = for_linkage[ decl->linkage ]; 370 208 371 209 ++stats.n_decls; … … 380 218 if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) { 381 219 if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) { 382 assnTy = dynamic_cast<FunctionType*>(ptrTy-> base);220 assnTy = dynamic_cast<FunctionType*>(ptrTy->get_base()); 383 221 } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type()); 384 222 } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) { … … 389 227 } 390 228 ++stats.n_assns[ n_assns ]; 391 ++stats.by_name[ decl->name ]; 229 230 ++stats.by_name[ decl->get_name() ]; 231 392 232 analyzeFunc( fnTy, stats, stats.params, stats.returns ); 393 233 } … … 426 266 template<typename F> 427 267 void printAllHisto( const std::string& name, F extract ) { 428 VectorMap<unsigned> histos[ n_named_specs];268 VectorMap<unsigned> histos[LinkageSpec::NoOfSpecs]; 429 269 VectorMap<unsigned> thisto; 430 270 431 271 for ( const auto& entry : extract(total) ) { ++thisto.at( entry.second ); } 432 272 433 for ( unsigned i = 0; i < n_named_specs; ++i ) {273 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { 434 274 // can't be a higher count in one of the sub-histograms than the total 435 275 histos[i].reserve( thisto.size() ); … … 449 289 template<typename F> 450 290 void printAllSparseHisto( const std::string& name, F extract ) { 451 std::map<unsigned, unsigned> histos[ n_named_specs];291 std::map<unsigned, unsigned> histos[LinkageSpec::NoOfSpecs]; 452 292 std::map<unsigned, unsigned> thisto; 453 293 454 294 for ( const auto& entry : extract(total) ) { ++thisto[ entry.second ]; } 455 295 456 for ( unsigned i = 0; i < n_named_specs; ++i ) {296 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { 457 297 for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; } 458 298 } … … 461 301 const auto& key = entry.first; 462 302 std::cout << "\"" << name << "\"," << key; 463 for ( unsigned i = 0; i < n_named_specs; ++i ) {303 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) { 464 304 auto it = histos[i].find( key ); 465 305 if ( it == histos[i].end() ) std::cout << ",0"; … … 473 313 void printAllPack( const std::string& name, F extract ) { 474 314 printAllMap("n_basic_" + name, [&extract](const Stats& stats) { return extract(stats).n_basic; }); 475 printAllMap("n_generic_" + name, [&extract](const Stats& stats) { return extract(stats).n_generic; });476 315 printAllMap("n_poly_" + name, [&extract](const Stats& stats) { return extract(stats).n_poly; }); 477 printAllMap("n_compound_" + name, [&extract](const Stats& stats) { return extract(stats).n_compound; });478 316 printAllMap("n_" + name, [&extract](const Stats& stats) { return extract(stats).n; }); 479 317 printAllMap("%_basic_" + name, [&extract](const Stats& stats) { return extract(stats).p_basic; }); 480 printAllMap("%_generic_" + name, [&extract](const Stats& stats) { return extract(stats).p_generic; });481 318 printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; }); 482 printAllMap("%_compound_" + name, [&extract](const Stats& stats) { return extract(stats).p_compound; });483 319 printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; }); 484 320 printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; }); … … 500 336 } 501 337 502 std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\" compiler\",\"builtinCFA\",\"builtinC\",\"other\",\"TOTAL\"" << std::endl;338 std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"builtin\",\"TOTAL\"" << std::endl; 503 339 504 340 printAllMap("n_type_params", [](const Stats& stats) { return stats.n_type_params; }); 505 printAllMap("n_generic_params", [](const Stats& stats) { return stats.n_generic_params; });506 printAllMap("n_generic_nesting", [](const Stats& stats) { return stats.n_generic_nesting; });507 341 printAll("n_decls", [](const Stats& stats) { return stats.n_decls; }); 508 342 printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); }); … … 511 345 printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; }); 512 346 printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; }); 513 printAll("generic_type_names", [](const Stats& stats) { return stats.generic_type_names.size(); });514 printAllSparseHisto("generic_type_uses", [](const Stats& stats) { return stats.generic_type_names; });515 printAllSparseHisto("decls_using_generic_type", [](const Stats& stats) { return stats.generic_type_decls; });516 347 printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); }); 517 348 printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; }); … … 528 359 }; 529 360 530 const unsigned DeclStats::ind_for_linkage[]531 = { 7, 7, 2, 1, 7, 7, 7, 3, 4, 7, 6, 5, 7, 7, 7, 0 };532 533 361 void printDeclStats( std::list< Declaration * > &translationUnit ) { 534 362 PassVisitor<DeclStats> stats;
Note:
See TracChangeset
for help on using the changeset viewer.
