Changeset f37147b for src/CodeTools

Timestamp:

Feb 28, 2017, 3:24:35 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

20221d4, dd020c0

Parents:

d0ffed1 (diff), 14f6bb39 (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.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

File:

• src/CodeTools/DeclStats.cc (modified) (13 diffs)

src/CodeTools/DeclStats.cc

@@ -63 +63 @@
                         std::map<unsigned, unsigned> p_poly;   ///< Count of decls with each percentage of polymorphic elements
                         VectorMap<unsigned> n_types;           ///< Count of decls with each number of distinct types in the pack
+                        /// Count of decls with each percentage of new types in lists.
+                        /// Types used in the parameter list that recur in the return list are not considered to be new.
+                        std::map<unsigned, unsigned> p_new;
 
                         ArgPackStats& operator+= (const ArgPackStats& o) {
@@ -71 +74 @@
                                 sum(p_poly, o.p_poly);
                                 sum(n_types, o.n_types);
+                                sum(p_new, o.p_new);
                                 
                                 return *this;
@@ -86 +90 @@
                         /// Count of uses of each non-basic type
                         std::unordered_map<std::string, unsigned> compound_type_names;
+                        /// Count of decls using each basic type
+                        std::unordered_map<std::string, unsigned> basic_type_decls;
+                        /// Count of decls using each compound type
+                        std::unordered_map<std::string, unsigned> compound_type_decls;
                         /// Stats for the parameter list
                         ArgPackStats params;
@@ -98 +106 @@
                         ArgPackStats assn_returns;
                         
-                        Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
+                        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() {}
 
                 public:
@@ -107 +115 @@
                                 sum( basic_type_names, o.basic_type_names );
                                 sum( compound_type_names, o.compound_type_names );
+                                sum( basic_type_decls, o.basic_type_decls );
+                                sum( compound_type_decls, o.compound_type_decls );
                                 sum( params, o.params );
                                 sum( returns, o.returns );
@@ -120 +130 @@
                 std::unordered_set<std::string> seen_names;  ///< Stores manglenames already seen to avoid double-counting
                 Stats total;
+                /// Count of expressions with (depth, fanout)
+                std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth;
 
                 /// Update arg pack stats based on a declaration list
-                void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
+                void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
                         std::unordered_set<std::string> types;
-                        unsigned n = 0;
-                        unsigned n_basic = 0;
-                        unsigned n_poly = 0;
+                        unsigned n = 0;        ///< number of args/returns
+                        unsigned n_basic = 0;  ///< number of basic types
+                        unsigned n_poly = 0;   ///< number of polymorphic types
+                        unsigned n_new = 0;    ///< number of new types
                         for ( auto decl : decls ) {
                                 Type* dt = decl->get_type();
@@ -135 +148 @@
                                 dt->print( ss );
                                 types.insert( ss.str() );
+                                bool this_new = seen.insert( ss.str() ).second;
+                                if ( this_new ) { ++n_new; }
 
                                 if ( dynamic_cast<BasicType*>( dt ) ) {
                                         ++n_basic;
                                         ++stats.basic_type_names[ ss.str() ];
+                                        if ( this_new ) {
+                                                ++stats.basic_type_decls[ ss.str() ];
+                                        }
                                 } else if ( GenPoly::hasPolyBase( dt ) ) {
                                         ++n_poly;
                                 } else {
                                         ++stats.compound_type_names[ ss.str() ];
+                                        if ( this_new ) {
+                                                ++stats.compound_type_decls[ ss.str() ];
+                                        }
                                 }
                         }
@@ -151 +172 @@
                                 ++pstats.p_basic[ n_basic*100/n ];
                                 ++pstats.p_poly[ n_poly*100/n ];
+                                ++pstats.p_new[ n_new*100/n ];
                         }
                         ++pstats.n_types.at( types.size() );
@@ -156 +178 @@
                 
                 void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
-                        analyze( stats, params, fnTy->get_parameters() );
-                        analyze( stats, returns, fnTy->get_returnVals() );
+                        std::unordered_set<std::string> seen;
+                        analyze( stats, seen, params, fnTy->get_parameters() );
+                        analyze( stats, seen, returns, fnTy->get_returnVals() );
+                }
+
+                void analyzeExpr( UntypedExpr *expr, unsigned depth ) {
+                        auto& args = expr->get_args();
+                        unsigned fanout = args.size();
+                        ++exprs_by_fanout_at_depth[ std::make_pair(depth, fanout) ];
+                        for ( Expression* arg : args ) {
+                                if ( UntypedExpr *uearg = dynamic_cast<UntypedExpr*>(arg) ) {
+                                        analyzeExpr( uearg, depth+1 );
+                                }
+                        }
                 }
 
@@ -196 +230 @@
                 }
 
+                virtual void visit( UntypedExpr *expr ) {
+                        analyzeExpr( expr, 0 );
+                }
+
         private:
                 template<typename F>
@@ -275 +313 @@
                         printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; });
                         printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; });
+                        printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; });
+                }
+
+                void printPairMap( const std::string& name, 
+                                   const std::map<std::pair<unsigned, unsigned>, unsigned>& map ) {
+                        for ( const auto& entry : map ) {
+                                const auto& key = entry.first;
+                                std::cout << "\"" << name << "\"," << key.first << "," << key.second << "," 
+                                          << entry.second << std::endl;
+                        }
                 }
                 
@@ -291 +339 @@
                         printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); });
                         printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; });
+                        printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; });
                         printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
                         printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; });
+                        printAllSparseHisto("decls_using_compound_type", [](const Stats& stats) { return stats.compound_type_decls; });
                         printAllPack("params", [](const Stats& stats) { return stats.params; });
                         printAllPack("returns", [](const Stats& stats) { return stats.returns; });
@@ -298 +348 @@
                         printAllPack("assn_params", [](const Stats& stats) { return stats.assn_params; });
                         printAllPack("assn_returns", [](const Stats& stats) { return stats.assn_returns; });
+                        std::cout << std::endl;
+
+                        printPairMap("exprs_by_depth+fanout", exprs_by_fanout_at_depth);
                 }
         };