Changeset f37147b


Ignore:
Timestamp:
Feb 28, 2017, 3:24:35 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
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:
20221d4, dd020c0
Parents:
d0ffed1 (diff), 14f6bb3 (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

Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/CodeTools/DeclStats.cc

    rd0ffed1 rf37147b  
    6363                        std::map<unsigned, unsigned> p_poly;   ///< Count of decls with each percentage of polymorphic elements
    6464                        VectorMap<unsigned> n_types;           ///< Count of decls with each number of distinct types in the pack
     65                        /// Count of decls with each percentage of new types in lists.
     66                        /// Types used in the parameter list that recur in the return list are not considered to be new.
     67                        std::map<unsigned, unsigned> p_new;
    6568
    6669                        ArgPackStats& operator+= (const ArgPackStats& o) {
     
    7174                                sum(p_poly, o.p_poly);
    7275                                sum(n_types, o.n_types);
     76                                sum(p_new, o.p_new);
    7377                               
    7478                                return *this;
     
    8690                        /// Count of uses of each non-basic type
    8791                        std::unordered_map<std::string, unsigned> compound_type_names;
     92                        /// Count of decls using each basic type
     93                        std::unordered_map<std::string, unsigned> basic_type_decls;
     94                        /// Count of decls using each compound type
     95                        std::unordered_map<std::string, unsigned> compound_type_decls;
    8896                        /// Stats for the parameter list
    8997                        ArgPackStats params;
     
    98106                        ArgPackStats assn_returns;
    99107                       
    100                         Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
     108                        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() {}
    101109
    102110                public:
     
    107115                                sum( basic_type_names, o.basic_type_names );
    108116                                sum( compound_type_names, o.compound_type_names );
     117                                sum( basic_type_decls, o.basic_type_decls );
     118                                sum( compound_type_decls, o.compound_type_decls );
    109119                                sum( params, o.params );
    110120                                sum( returns, o.returns );
     
    120130                std::unordered_set<std::string> seen_names;  ///< Stores manglenames already seen to avoid double-counting
    121131                Stats total;
     132                /// Count of expressions with (depth, fanout)
     133                std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth;
    122134
    123135                /// Update arg pack stats based on a declaration list
    124                 void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
     136                void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
    125137                        std::unordered_set<std::string> types;
    126                         unsigned n = 0;
    127                         unsigned n_basic = 0;
    128                         unsigned n_poly = 0;
     138                        unsigned n = 0;        ///< number of args/returns
     139                        unsigned n_basic = 0;  ///< number of basic types
     140                        unsigned n_poly = 0;   ///< number of polymorphic types
     141                        unsigned n_new = 0;    ///< number of new types
    129142                        for ( auto decl : decls ) {
    130143                                Type* dt = decl->get_type();
     
    135148                                dt->print( ss );
    136149                                types.insert( ss.str() );
     150                                bool this_new = seen.insert( ss.str() ).second;
     151                                if ( this_new ) { ++n_new; }
    137152
    138153                                if ( dynamic_cast<BasicType*>( dt ) ) {
    139154                                        ++n_basic;
    140155                                        ++stats.basic_type_names[ ss.str() ];
     156                                        if ( this_new ) {
     157                                                ++stats.basic_type_decls[ ss.str() ];
     158                                        }
    141159                                } else if ( GenPoly::hasPolyBase( dt ) ) {
    142160                                        ++n_poly;
    143161                                } else {
    144162                                        ++stats.compound_type_names[ ss.str() ];
     163                                        if ( this_new ) {
     164                                                ++stats.compound_type_decls[ ss.str() ];
     165                                        }
    145166                                }
    146167                        }
     
    151172                                ++pstats.p_basic[ n_basic*100/n ];
    152173                                ++pstats.p_poly[ n_poly*100/n ];
     174                                ++pstats.p_new[ n_new*100/n ];
    153175                        }
    154176                        ++pstats.n_types.at( types.size() );
     
    156178               
    157179                void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
    158                         analyze( stats, params, fnTy->get_parameters() );
    159                         analyze( stats, returns, fnTy->get_returnVals() );
     180                        std::unordered_set<std::string> seen;
     181                        analyze( stats, seen, params, fnTy->get_parameters() );
     182                        analyze( stats, seen, returns, fnTy->get_returnVals() );
     183                }
     184
     185                void analyzeExpr( UntypedExpr *expr, unsigned depth ) {
     186                        auto& args = expr->get_args();
     187                        unsigned fanout = args.size();
     188                        ++exprs_by_fanout_at_depth[ std::make_pair(depth, fanout) ];
     189                        for ( Expression* arg : args ) {
     190                                if ( UntypedExpr *uearg = dynamic_cast<UntypedExpr*>(arg) ) {
     191                                        analyzeExpr( uearg, depth+1 );
     192                                }
     193                        }
    160194                }
    161195
     
    196230                }
    197231
     232                virtual void visit( UntypedExpr *expr ) {
     233                        analyzeExpr( expr, 0 );
     234                }
     235
    198236        private:
    199237                template<typename F>
     
    275313                        printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; });
    276314                        printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; });
     315                        printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; });
     316                }
     317
     318                void printPairMap( const std::string& name,
     319                                   const std::map<std::pair<unsigned, unsigned>, unsigned>& map ) {
     320                        for ( const auto& entry : map ) {
     321                                const auto& key = entry.first;
     322                                std::cout << "\"" << name << "\"," << key.first << "," << key.second << ","
     323                                          << entry.second << std::endl;
     324                        }
    277325                }
    278326               
     
    291339                        printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); });
    292340                        printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; });
     341                        printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; });
    293342                        printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
    294343                        printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; });
     344                        printAllSparseHisto("decls_using_compound_type", [](const Stats& stats) { return stats.compound_type_decls; });
    295345                        printAllPack("params", [](const Stats& stats) { return stats.params; });
    296346                        printAllPack("returns", [](const Stats& stats) { return stats.returns; });
     
    298348                        printAllPack("assn_params", [](const Stats& stats) { return stats.assn_params; });
    299349                        printAllPack("assn_returns", [](const Stats& stats) { return stats.assn_returns; });
     350                        std::cout << std::endl;
     351
     352                        printPairMap("exprs_by_depth+fanout", exprs_by_fanout_at_depth);
    300353                }
    301354        };
  • src/Parser/ParseNode.h

    rd0ffed1 rf37147b  
    109109        ExpressionNode( const ExpressionNode &other );
    110110        virtual ~ExpressionNode() {}
    111         virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
     111        virtual ExpressionNode * clone() const override { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
    112112
    113113        bool get_extension() const { return extension; }
     
    259259        DeclarationNode();
    260260        ~DeclarationNode();
    261         DeclarationNode * clone() const;
     261        DeclarationNode * clone() const override;
    262262
    263263        DeclarationNode * addQualifiers( DeclarationNode * );
  • src/libcfa/concurrency/invoke.h

    rd0ffed1 rf37147b  
    6060
    6161      struct coStack_t {
    62             unsigned int size;          // size of stack
    63             void *storage;                      // pointer to stack
    64             void *limit;                        // stack grows towards stack limit
    65             void *base;                         // base of stack
    66             void *context;                      // address of cfa_context_t
    67             void *top;                          // address of top of storage
     62            unsigned int size;                // size of stack
     63            void *storage;                            // pointer to stack
     64            void *limit;                              // stack grows towards stack limit
     65            void *base;                               // base of stack
     66            void *context;                            // address of cfa_context_t
     67            void *top;                                // address of top of storage
    6868            bool userStack;     
    6969      };
     
    7373      struct coroutine {
    7474            struct coStack_t stack;
    75             const char *name;                   // textual name for coroutine/task, initialized by uC++ generated code
    76             int errno_;                         // copy of global UNIX variable errno
    77             enum coroutine_state state; // current execution status for coroutine
    78             struct coroutine *starter;  // first coroutine to resume this one
    79             struct coroutine *last;             // last coroutine to resume this one
     75            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
     76            int errno_;                               // copy of global UNIX variable errno
     77            enum coroutine_state state;       // current execution status for coroutine
     78            struct coroutine *starter;        // first coroutine to resume this one
     79            struct coroutine *last;                   // last coroutine to resume this one
    8080      };
    8181
    8282      struct thread {
    83             struct coroutine c;           // coroutine body used to store context
    84             struct signal_once terminated;// indicate if execuation state is not halted
    85             struct thread * next;         // instrusive link field for threads
     83            struct coroutine c;                 // coroutine body used to store context
     84            struct signal_once terminated;      // indicate if execuation state is not halted
     85            struct thread * next;               // instrusive link field for threads
    8686      };
    8787
  • src/libcfa/concurrency/monitor

    rd0ffed1 rf37147b  
    2121#include "invoke.h"
    2222
    23 struct monitor {
     23struct __monitor_t {
    2424        spinlock lock;
    25         thread * holder;
     25        thread * owner;
    2626        simple_thread_list entry_queue;
     27        unsigned int recursion;
    2728};
    2829
    29 void enter(monitor *);
    30 void leave(monitor *);
     30static inline void ?{}(__monitor_t * this) {
     31        this->owner = 0;
     32        this->recursion = 0;
     33}
    3134
    32 struct monitor_guard {
    33         monitor * m;
     35void enter(__monitor_t *);
     36void leave(__monitor_t *);
     37
     38struct monitor_guard_t {
     39        __monitor_t * m;
    3440};
    3541
    36 static inline void ?{}( monitor_guard * this, monitor * m ) {
     42static inline void ?{}( monitor_guard_t * this, __monitor_t * m ) {
    3743        this->m = m;
    3844        enter( this->m );
    3945}
    4046
    41 static inline void ^?{}( monitor_guard * this ) {
     47static inline void ^?{}( monitor_guard_t * this ) {
    4248        leave( this->m );
    4349}
  • src/libcfa/concurrency/monitor.c

    rd0ffed1 rf37147b  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // monitor.c --
     8// __monitor_t.c --
    99//
    1010// Author           : Thierry Delisle
     
    1919#include "kernel_private.h"
    2020
    21 void enter(monitor * this) {
     21void enter(__monitor_t * this) {
    2222        lock( &this->lock );
    2323        thread * thrd = this_thread();
    2424
    25         if( this->holder ) {
     25        if( !this->owner ) {
     26                //No one has the monitor, just take it
     27                this->owner = thrd;
     28                this->recursion = 1;
     29        }
     30        else if( this->owner == thrd) {
     31                //We already have the monitor, just not how many times we took it
     32                assert( this->recursion > 0 );
     33                this->recursion += 1;
     34        }
     35        else {
     36                //Some one else has the monitor, wait in line for it
    2637                append( &this->entry_queue, thrd );
    2738                ScheduleInternal( &this->lock );
    28                 return;
    29         }
    30         else {
    31                 this->holder = thrd;
     39
     40                //ScheduleInternal will unlock spinlock, no need to unlock ourselves
     41                return;
    3242        }
    3343
     
    3545}
    3646
    37 void leave(monitor * this) {
     47void leave(__monitor_t * this) {
    3848        lock( &this->lock );
    3949
    4050        thread * thrd = this_thread();
    41         assert( thrd == this->holder );
     51        assert( thrd == this->owner );
    4252
    43         this->holder = pop_head( &this->entry_queue );
     53        //Leaving a recursion level, decrement the counter
     54        this->recursion -= 1;
     55
     56        //If we left the last level of recursion it means we are changing who owns the monitor
     57        thread * new_owner = 0;
     58        if( this->recursion == 0) {
     59                //Get the next thread in the list
     60                new_owner = this->owner = pop_head( &this->entry_queue );
     61
     62                //We are passing the monitor to someone else, which means recursion level is not 0
     63                this->recursion = new_owner ? 1 : 0;
     64        }       
    4465
    4566        unlock( &this->lock );
    4667
    47         if( this->holder ) ScheduleThread( this->holder );
     68        //If we have a new owner, we need to wake-up the thread
     69        if( new_owner ) {
     70                ScheduleThread( new_owner );
     71        }
    4872}
  • src/prelude/prelude.cf

    rd0ffed1 rf37147b  
    131131                !?( float _Complex ),           !?( double _Complex ),          !?( long double _Complex );
    132132
     133forall ( dtype DT ) int !?(                DT * );
     134forall ( dtype DT ) int !?( const          DT * );
     135forall ( dtype DT ) int !?(       volatile DT * );
    133136forall ( dtype DT ) int !?( const volatile DT * );
    134137forall ( ftype FT ) int !?( FT * );
     
    235238           ?>?( long double, long double ),                             ?>=?( long double, long double );
    236239
     240forall( dtype DT ) signed int ?<?(                 DT *,                DT * );
     241forall( dtype DT ) signed int ?<?(  const          DT *, const          DT * );
     242forall( dtype DT ) signed int ?<?(        volatile DT *,       volatile DT * );
    237243forall( dtype DT ) signed int ?<?(  const volatile DT *, const volatile DT * );
     244
     245forall( dtype DT ) signed int ?>?(                 DT *,                DT * );
     246forall( dtype DT ) signed int ?>?(  const          DT *, const          DT * );
     247forall( dtype DT ) signed int ?>?(        volatile DT *,       volatile DT * );
    238248forall( dtype DT ) signed int ?>?(  const volatile DT *, const volatile DT * );
     249
     250forall( dtype DT ) signed int ?<=?(                 DT *,                DT * );
     251forall( dtype DT ) signed int ?<=?(  const          DT *, const          DT * );
     252forall( dtype DT ) signed int ?<=?(        volatile DT *,       volatile DT * );
    239253forall( dtype DT ) signed int ?<=?( const volatile DT *, const volatile DT * );
     254
     255forall( dtype DT ) signed int ?>=?(                 DT *,                DT * );
     256forall( dtype DT ) signed int ?>=?(  const          DT *, const          DT * );
     257forall( dtype DT ) signed int ?>=?(        volatile DT *,       volatile DT * );
    240258forall( dtype DT ) signed int ?>=?( const volatile DT *, const volatile DT * );
    241259
  • src/tests/avltree/avl_test.c

    rd0ffed1 rf37147b  
    3636
    3737  // char* -> char*
    38   int ?<?(char *a, char *b) {
    39     return strcmp(a,b) < 0;
     38  struct c_str { char *str; };  // wraps a C string
     39  int ?<?(c_str a, c_str b) {
     40    return strcmp(a.str,b.str) < 0;
    4041  }
    41   tree(char *, char *) * ssmap = create("queso", "cheese");
    42   insert(&ssmap, "foo", "bar");
    43   insert(&ssmap, "hello", "world");
     42  tree(c_str, char *) * ssmap = create((c_str){"queso"}, "cheese");
     43  insert(&ssmap, (c_str){"foo"}, "bar");
     44  insert(&ssmap, (c_str){"hello"}, "world");
    4445  assert( height(ssmap) == 2 );
    4546
    46   printf("%s %s %s\n", *find(ssmap, "hello"), *find(ssmap, "foo"), *find(ssmap, "queso"));
     47  printf("%s %s %s\n", *find(ssmap, (c_str){"hello"}), *find(ssmap, (c_str){"foo"}), *find(ssmap, (c_str){"queso"}));
    4748
    48   remove(&ssmap, "foo");
     49  remove(&ssmap, (c_str){"foo"});
    4950  delete(ssmap);
    5051}
  • src/tests/monitor.c

    rd0ffed1 rf37147b  
    66struct global_t {
    77        int value;
    8         monitor m;
     8        __monitor_t m;
    99};
    1010
     
    1616
    1717void increment( /*mutex*/ global_t * this ) {
    18         monitor_guard g = { &this->m };
    19         this->value += 1;
     18        monitor_guard_t g1 = { &this->m };
     19        {
     20                monitor_guard_t g2 = { &this->m };
     21                {
     22                        monitor_guard_t g3 = { &this->m };
     23                        this->value += 1;
     24                }
     25        }
    2026}
    2127
Note: See TracChangeset for help on using the changeset viewer.