Changes in / [3e5dd913:53449a4]


Ignore:
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/bits/collection.hfa

    r3e5dd913 r53449a4  
    11#pragma once
     2#include <stdio.h> // REMOVE THIS AFTER DEBUGGING
     3
    24
    35struct Colable {
    4         Colable * next;                                                                         // next node in the list
     6        struct Colable * next;                                                                          // next node in the list
    57        // invariant: (next != 0) <=> listed()
    68};
    7 
    8 inline {
     9#ifdef __cforall
     10static inline {
    911        // PUBLIC
    1012
     
    2830        }
    2931
    30         // wrappers to make Collection have T
    31         forall( dtype T ) {
    32                 T *& Next( T * n ) {
    33                         return (T *)Next( (Colable *)n );
    34                 }
     32        // // wrappers to make Collection have T
     33        // forall( dtype T ) {
     34        //      T *& Next( T * n ) {
     35        //              return (T *)Next( (Colable *)n );
     36        //      }
    3537
    36                 bool listed( T * n ) {
    37                         return Next( (Colable *)n ) != 0p;
    38                 }
    39         } // distribution
     38        //      bool listed( T * n ) {
     39        //              return Next( (Colable *)n ) != 0p;
     40        //      }
     41        // } // distribution
    4042} // distribution
    4143
     
    4547};
    4648
    47 inline {
     49static inline {
    4850        // class invariant: root == 0 & empty() | *root in *this
    4951        void ?{}( Collection &, const Collection & ) = void; // no copy
     
    6870};
    6971
    70 inline {
     72static inline {
    7173        void ?{}( ColIter & colIter ) with( colIter ) {
    7274                curr = 0p;
     
    7981        } // distribution
    8082} // distribution
     83#endif
  • libcfa/src/bits/containers.hfa

    r3e5dd913 r53449a4  
    3636        #define __small_array_t(T) __small_array(T)
    3737#else
    38         #define __small_array_t(T) struct __small_array
     38        #define __small_array_t(T) __small_array
    3939#endif
    4040
  • libcfa/src/bits/defs.hfa

    r3e5dd913 r53449a4  
    2929#define __cfa_anonymous_object(x) inline struct x
    3030#else
    31 #define __cfa_anonymous_object(x) x __cfa_anonymous_object
     31#define __cfa_anonymous_object(x) struct x __cfa_anonymous_object
    3232#endif
    3333
  • libcfa/src/bits/queue.hfa

    r3e5dd913 r53449a4  
    33#include "bits/collection.hfa"
    44
    5 forall( dtype T ) {
     5forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    66        struct Queue {
    77                inline Collection;                                                              // Plan 9 inheritance
     
    6464                        T & t = head( q );
    6565                        if ( root ) {
    66                                 root = Next( root );
     66                                root = Next( (T *)root );
    6767                                if ( &head( q ) == &t ) {
    6868                                        root = last = 0p;                                       // only one element
     
    142142} // distribution
    143143
    144 forall( dtype T ) {
     144forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    145145        struct QueueIter {
    146146                inline ColIter;                                                                 // Plan 9 inheritance
  • libcfa/src/bits/sequence.hfa

    r3e5dd913 r53449a4  
    22
    33#include "bits/collection.hfa"
     4#include "bits/defs.hfa"
    45
    56struct Seqable {
    6         inline Colable;
    7         Seqable * back;                                                                         // pointer to previous node in the list
     7        __cfa_anonymous_object(Colable);
     8        struct Seqable * back;                                                                          // pointer to previous node in the list
    89};
    910
    10 inline {
     11#ifdef __cforall
     12static inline {
    1113        // PUBLIC
    1214
     
    2628        }
    2729
    28         // wrappers to make Collection have T
    29         forall( dtype T ) {
    30                 T *& Back( T * n ) {
    31                         return (T *)Back( (Seqable *)n );
    32                 }
    33         } // distribution
     30        // // wrappers to make Collection have T
     31        // forall( dtype T ) {
     32        //      T *& Back( T * n ) {
     33        //              return (T *)Back( (Seqable *)n );
     34        //      }
     35        // } // distribution
    3436} // distribution
    3537
    36 forall( dtype T ) {
     38forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
    3739        struct Sequence {
    3840                inline Collection;                                                              // Plan 9 inheritance
    3941        };
    4042
    41         inline {
     43        static inline {
    4244                // wrappers to make Collection have T
    4345                T & head( Sequence(T) & s ) with( s ) {
     
    184186                                T * toEnd = Back( &head( s ) );
    185187                                T * fromEnd = Back( &head( from ) );
    186                                 Back( root ) = fromEnd;
     188                                Back( (T *)root ) = fromEnd;
    187189                                Next( fromEnd ) = &head( s );
    188                                 Back( from.root ) = toEnd;
     190                                Back( (T *)from.root ) = toEnd;
    189191                                Next( toEnd ) = &head( from );
    190192                        } // if
     
    214216} // distribution
    215217
    216 forall( dtype T ) {
     218forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
    217219        // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
    218220        struct SeqIter {
     
    224226        };
    225227
    226         inline {
     228        static inline {
    227229                void ?{}( SeqIter(T) & si ) with( si ) {
    228230                        ((ColIter &)si){};
     
    265267        };
    266268
    267         inline {
     269        static inline {
    268270                void ?{}( SeqIterRev(T) & si ) with( si ) {     
    269271                        ((ColIter &)si){};
     
    298300        } // distribution
    299301} // distribution
     302
     303#endif
  • libcfa/src/bits/stack.hfa

    r3e5dd913 r53449a4  
    33#include "bits/collection.hfa"
    44
    5 forall( dtype T ) {
     5forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    66        struct Stack {
    77                inline Collection;                                                              // Plan 9 inheritance
     
    4444                        T & t = head( s );
    4545                        if ( root ) {
    46                                 root = ( T *)Next( root );
     46                                root = ( T *)Next( (T *)root );
    4747                                if ( &head( s ) == &t ) root = 0p;              // only one element ?
    4848                                Next( &t ) = 0p;
     
    5858
    5959
    60 forall( dtype T ) {
     60forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    6161        struct StackIter {
    6262                inline ColIter;                                                                 // Plan 9 inheritance
  • libcfa/src/concurrency/invoke.h

    r3e5dd913 r53449a4  
    189189                struct __monitor_group_t monitors;
    190190
     191                // used to put threads on user data structures
     192                struct {
     193                        struct $thread * next;
     194                        struct $thread * back;
     195                } seqable;
     196
    191197                struct {
    192198                        struct $thread * next;
     
    218224                }
    219225
     226                static inline $thread *& Back( $thread * this ) __attribute__((const)) {
     227                        return this->seqable.back;
     228                }
     229
     230                static inline $thread *& Next( $thread * this ) __attribute__((const)) {
     231                        return this->seqable.next;
     232                }
     233
     234                static inline bool listed( $thread * this ) {
     235                        return this->seqable.next != 0p;
     236                }
     237
    220238                static inline void ?{}(__monitor_group_t & this) {
    221239                        (this.data){0p};
  • libcfa/src/concurrency/locks.cfa

    r3e5dd913 r53449a4  
    2929
    3030        void ^?{}( info_thread(L) & this ){ }
     31
     32        info_thread(L) *& Back( info_thread(L) * this ) {
     33                return (info_thread(L) *)Back( (Seqable *)this );
     34        }
     35
     36        info_thread(L) *& Next( info_thread(L) * this ) {
     37                return (info_thread(L) *)Next( (Colable *)this );
     38        }
     39
     40        bool listed( info_thread(L) * this ) {
     41                return Next( (Colable *)this ) != 0p;
     42        }
    3143}
    3244
     
    5870                abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
    5971        } else if ( owner != 0p && owner != active_thread() ) {
    60                 append( blocked_threads, active_thread() );
     72                addTail( blocked_threads, *active_thread() );
    6173                wait_count++;
    6274                unlock( lock );
     
    96108
    97109void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
    98         $thread * t = pop_head( blocked_threads );
     110        $thread * t = &dropHead( blocked_threads );
    99111        owner = t;
    100112        recursion_count = ( t ? 1 : 0 );
     
    128140    lock( lock __cfaabi_dbg_ctx2 );
    129141        if ( owner != 0p ) {
    130                 append( blocked_threads, t );
     142                addTail( blocked_threads, *t );
    131143                wait_count++;
    132144                unlock( lock );
     
    257269                size_t recursion_count = 0;
    258270                if (i->lock) {
    259                         i->t->link.next = 1p;
    260271                        recursion_count = get_recursion_count(*i->lock);
    261272                        remove_( *i->lock );
  • libcfa/src/concurrency/locks.hfa

    r3e5dd913 r53449a4  
    4343        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
    4444        void ^?{}( info_thread(L) & this );
     45
     46        info_thread(L) *& Back( info_thread(L) * this );
     47        info_thread(L) *& Next( info_thread(L) * this );
     48        bool listed( info_thread(L) * this );
    4549}
    4650
     
    6468
    6569        // List of blocked threads
    66         __queue_t( $thread ) blocked_threads;
     70        Sequence( $thread ) blocked_threads;
    6771
    6872        // Count of current blocked threads
  • libcfa/src/concurrency/thread.cfa

    r3e5dd913 r53449a4  
    4343                canary = 0x0D15EA5E0D15EA5Ep;
    4444        #endif
     45
     46        seqable.next = 0p;
     47        seqable.back = 0p;
    4548
    4649        node.next = 0p;
  • tests/queue.cfa

    r3e5dd913 r53449a4  
    1313        void ?{}( Fred & fred, int p ) with( fred ) {
    1414                i = p;
     15        }
     16        Fred *& Next( Fred * n ) {
     17                return (Fred *)Next( (Colable *)n );
     18        }
     19
     20        bool listed( Fred * n ) {
     21                return Next( (Colable *)n ) != 0p;
    1522        }
    1623
     
    6875        }
    6976
     77        Mary *& Next( Mary * n ) {
     78                return (Mary *)Next( (Colable *)n );
     79        }
     80
     81        bool listed( Mary * n ) {
     82                return Next( (Colable *)n ) != 0p;
     83        }
     84
    7085        Queue(Mary) mary;
    7186        QueueIter(Mary) maryIter = { mary };
  • tests/sequence.cfa

    r3e5dd913 r53449a4  
    1313        void ?{}( Fred & fred, int p ) with( fred ) {
    1414                i = p;
     15        }
     16
     17        Fred *& Back( Fred * n ) {
     18                return (Fred *)Back( (Seqable *)n );
     19        }
     20
     21        Fred *& Next( Fred * n ) {
     22                return (Fred *)Next( (Colable *)n );
     23        }
     24
     25        bool listed( Fred * n ) {
     26                return Next( (Colable *)n ) != 0p;
    1527        }
    1628
     
    7688        }
    7789
     90        Mary *& Back( Mary * n ) {
     91                return (Mary *)Back( (Seqable *)n );
     92        }
     93
     94        Mary *& Next( Mary * n ) {
     95                return (Mary *)Next( (Colable *)n );
     96        }
     97
     98        bool listed( Mary * n ) {
     99                return Next( (Colable *)n ) != 0p;
     100        }
     101
    78102        Sequence(Mary) mary;
    79103        Sequence(Mary) baz;
  • tests/stack.cfa

    r3e5dd913 r53449a4  
    1313        void ?{}( Fred & fred, int p ) with( fred ) {
    1414                i = p;
     15        }
     16        Fred *& Next( Fred * n ) {
     17                return (Fred *)Next( (Colable *)n );
     18        }
     19
     20        bool listed( Fred * n ) {
     21                return Next( (Colable *)n ) != 0p;
    1522        }
    1623
     
    6875        }
    6976
     77        Mary *& Next( Mary * n ) {
     78                return (Mary *)Next( (Colable *)n );
     79        }
     80
     81        bool listed( Mary * n ) {
     82                return Next( (Colable *)n ) != 0p;
     83        }
     84
    7085        Stack(Mary) mary;
    7186        StackIter(Mary) maryIter = { mary };
Note: See TracChangeset for help on using the changeset viewer.