Changeset e23d20b
 Timestamp:
 Jan 22, 2018, 5:03:19 PM (5 years ago)
 Branches:
 aaronthesis, armeh, cleanupdtors, deferred_resn, demangler, enum, forallpointerdecay, jacob/cs343translation, jenkinssandbox, master, newast, newastuniqueexpr, newenv, no_list, persistentindexer, pthreademulation, qualifiedEnum, resolvnew, with_gc
 Children:
 84e8423, fc67d6f
 Parents:
 b04a408 (diff), 9cdfb4d0 (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.  File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

src/CodeTools/DeclStats.cc
rb04a408 re23d20b 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_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 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 nongeneric 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 nongeneric compound type elements 73 VectorMap<unsigned> n_types; ///< Count of decls with each number of distinct types in the pack 70 74 /// Count of decls with each percentage of new types in lists. 71 75 /// Types used in the parameter list that recur in the return list are not considered to be new. … … 75 79 sum(n, o.n); 76 80 sum(n_basic, o.n_basic); 81 sum(n_generic, o.n_generic); 77 82 sum(n_poly, o.n_poly); 83 sum(n_compound, o.n_compound); 78 84 sum(p_basic, o.p_basic); 85 sum(p_generic, o.p_generic); 79 86 sum(p_poly, o.p_poly); 87 sum(p_compound, o.p_compound); 80 88 sum(n_types, o.n_types); 81 89 sum(p_new, o.p_new); … … 89 97 /// Count of declarations with each number of assertion parameters 90 98 VectorMap<unsigned> n_type_params; 99 /// Count of generic types with each number of type parameters 100 VectorMap<unsigned> n_generic_params; 101 /// Count of maximum nesting depth of types 102 VectorMap<unsigned> n_generic_nesting; 91 103 /// Count of declarations with each name 92 104 std::unordered_map<std::string, unsigned> by_name; 93 105 /// Count of uses of each basic type 94 106 std::unordered_map<std::string, unsigned> basic_type_names; 95 /// Count of uses of each nonbasic type 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 nongeneric aggregate type 96 110 std::unordered_map<std::string, unsigned> compound_type_names; 97 111 /// Count of decls using each basic type 98 112 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; 99 115 /// Count of decls using each compound type 100 116 std::unordered_map<std::string, unsigned> compound_type_decls; … … 111 127 ArgPackStats assn_returns; 112 128 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() {} 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() {} 114 133 115 134 public: … … 117 136 sum( n_decls, o.n_decls ); 118 137 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 ); 119 140 sum( by_name, o.by_name ); 120 141 sum( basic_type_names, o.basic_type_names ); 142 sum( generic_type_names, o.generic_type_names ); 121 143 sum( compound_type_names, o.compound_type_names ); 122 144 sum( basic_type_decls, o.basic_type_decls ); 145 sum( generic_type_decls, o.generic_type_decls ); 123 146 sum( compound_type_decls, o.compound_type_decls ); 124 147 sum( params, o.params ); … … 132 155 }; 133 156 134 Stats for_linkage[LinkageSpec::NoOfSpecs]; ///< Stores separate stats per linkage 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 135 163 std::unordered_set<std::string> seen_names; ///< Stores manglenames already seen to avoid doublecounting 136 164 Stats total; … … 138 166 std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth; 139 167 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 140 301 /// Update arg pack stats based on a declaration list 141 void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) { 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 ) { 142 305 std::unordered_set<std::string> types; 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 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 nongeneric aggregate types 311 unsigned n_new = 0; ///< number of new types 312 147 313 for ( auto decl : decls ) { 148 314 Type* dt = decl>get_type(); … … 153 319 dt>print( ss ); 154 320 types.insert( ss.str() ); 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 } 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 173 330 ++pstats.n.at( n ); 174 331 ++pstats.n_basic.at( n_basic ); 332 ++pstats.n_generic.at( n_generic ); 175 333 ++pstats.n_poly.at( n_poly ); 334 ++pstats.n_compound.at( n_agg ); 176 335 if ( n > 0 ) { 177 336 ++pstats.p_basic[ n_basic*100/n ]; 337 ++pstats.p_generic[ n_generic*100/n ]; 178 338 ++pstats.p_poly[ n_poly*100/n ]; 179 ++pstats.p_new[ n_new*100/n ]; 339 ++pstats.p_compound[ n_agg*100/n ]; 340 if ( n > 1 ) ++pstats.p_new[ (n_new1)*100/(n1) ]; 180 341 } 181 342 ++pstats.n_types.at( types.size() ); … … 184 345 void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) { 185 346 std::unordered_set<std::string> seen; 186 analyze( stats, seen, params, fnTy>get_parameters() ); 187 analyze( stats, seen, returns, fnTy>get_returnVals() ); 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() ); 188 350 } 189 351 … … 205 367 const std::string& mangleName = decl>get_mangleName().empty() ? decl>name : decl>get_mangleName(); 206 368 if ( seen_names.insert( mangleName ).second ) { 207 Stats& stats = for_linkage[ decl>linkage];369 Stats& stats = for_linkage[ ind_for_linkage[ decl>linkage ] ]; 208 370 209 371 ++stats.n_decls; … … 218 380 if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) { 219 381 if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj>get_type()) ) { 220 assnTy = dynamic_cast<FunctionType*>(ptrTy> get_base());382 assnTy = dynamic_cast<FunctionType*>(ptrTy>base); 221 383 } else assnTy = dynamic_cast<FunctionType*>(assnObj>get_type()); 222 384 } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) { … … 227 389 } 228 390 ++stats.n_assns[ n_assns ]; 229 230 ++stats.by_name[ decl>get_name() ]; 231 391 ++stats.by_name[ decl>name ]; 232 392 analyzeFunc( fnTy, stats, stats.params, stats.returns ); 233 393 } … … 266 426 template<typename F> 267 427 void printAllHisto( const std::string& name, F extract ) { 268 VectorMap<unsigned> histos[ LinkageSpec::NoOfSpecs];428 VectorMap<unsigned> histos[n_named_specs]; 269 429 VectorMap<unsigned> thisto; 270 430 271 431 for ( const auto& entry : extract(total) ) { ++thisto.at( entry.second ); } 272 432 273 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {433 for ( unsigned i = 0; i < n_named_specs; ++i ) { 274 434 // can't be a higher count in one of the subhistograms than the total 275 435 histos[i].reserve( thisto.size() ); … … 289 449 template<typename F> 290 450 void printAllSparseHisto( const std::string& name, F extract ) { 291 std::map<unsigned, unsigned> histos[ LinkageSpec::NoOfSpecs];451 std::map<unsigned, unsigned> histos[n_named_specs]; 292 452 std::map<unsigned, unsigned> thisto; 293 453 294 454 for ( const auto& entry : extract(total) ) { ++thisto[ entry.second ]; } 295 455 296 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {456 for ( unsigned i = 0; i < n_named_specs; ++i ) { 297 457 for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; } 298 458 } … … 301 461 const auto& key = entry.first; 302 462 std::cout << "\"" << name << "\"," << key; 303 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {463 for ( unsigned i = 0; i < n_named_specs; ++i ) { 304 464 auto it = histos[i].find( key ); 305 465 if ( it == histos[i].end() ) std::cout << ",0"; … … 313 473 void printAllPack( const std::string& name, F extract ) { 314 474 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; }); 315 476 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; }); 316 478 printAllMap("n_" + name, [&extract](const Stats& stats) { return extract(stats).n; }); 317 479 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; }); 318 481 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; }); 319 483 printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; }); 320 484 printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; }); … … 336 500 } 337 501 338 std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\" builtin\",\"TOTAL\"" << std::endl;502 std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"compiler\",\"builtinCFA\",\"builtinC\",\"other\",\"TOTAL\"" << std::endl; 339 503 340 504 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; }); 341 507 printAll("n_decls", [](const Stats& stats) { return stats.n_decls; }); 342 508 printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); }); … … 345 511 printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; }); 346 512 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; }); 347 516 printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); }); 348 517 printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; }); … … 359 528 }; 360 529 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 361 533 void printDeclStats( std::list< Declaration * > &translationUnit ) { 362 534 PassVisitor<DeclStats> stats;
Note: See TracChangeset
for help on using the changeset viewer.