source: doc/working/unified_semaphores/semaphore.cfa@ b24cbaf

#include "semaphore.hfa"
#include "kernel_private.hfa"
#include <stdlib.h>
#include <stdio.h>

#include <kernel.hfa>
#include <stdlib.hfa>
#include <thread.hfa>

forall(dtype L | is_blocking_lock(L)) {

        void ?{}(base_semaphore(L) & this, int count, bool is_binary) {
                this.count = count;
                this.lock{};
                this.blocked_threads{};
                this.is_binary = is_binary;
        }

        void ^?{}(base_semaphore(L) & this) {
                // default
        }

        void ?{}(binary_semaphore(L) & this) {
                ((base_semaphore(L) &)this){ 1, true };
        }

        void ?{}(binary_semaphore(L) & this, int count) {
                ((base_semaphore(L) &)this){ count, true };
        }

        void ^?{}(binary_semaphore(L) & this) {
                // default
        }

        void ?{}(counting_semaphore(L) & this) {
                ((base_semaphore(L) &)this){ 1, false };
        }

        void ?{}(counting_semaphore(L) & this, int count) {
                ((base_semaphore(L) &)this){ count, false };
        }

        void ^?{}(counting_semaphore(L) & this) {
                // default
        }

        void ?{}( alarm_node_semaphore(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) {
                this.alarm_node{ thrd, alarm, period, callback };
        }

        void ^?{}( alarm_node_semaphore(L) & this ) {

        }

        void add_( base_semaphore(L) & this, struct $thread * t ) with( this ) {
                lock( lock __cfaabi_dbg_ctx2 );
                #if !defined( __CFA_NO_STATISTICS__ )
                        kernelTLS.this_stats = t->curr_cluster->stats;
                #endif
                unpark( t );
                unlock( lock );
        }

        void remove_( base_semaphore(L) & this ) with( this ) {
                V(this);
        }

        ////////////////////////////////////////////////////////////////////////////////
        // These extras are needed since the inheritance is broken with traits
        ////////////////////////////////////////////////////////////////////////////////

        void add_( binary_semaphore(L) & this, struct $thread * t ) with( this ) {
                add_( (base_semaphore(L) &)this, t );
        }

        void remove_( binary_semaphore(L) & this ) with( this ) {
                remove_( (base_semaphore(L) &)this );
        }

        void add_( counting_semaphore(L) & this, struct $thread * t ) with( this ) {
                add_( (base_semaphore(L) &)this, t );
        }

        void remove_( counting_semaphore(L) & this ) with( this ) {
                remove_( (base_semaphore(L) &)this );
        }

        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////

        void timeout_handler ( alarm_node_semaphore(L) & this ) with( this ) {
        // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
            lock( sem->lock __cfaabi_dbg_ctx2 );
            if ( (*i)->listed ) {                       // is thread on queue
                info_thread(L) * copy = *i;
                        remove( sem->blocked_threads, i );               //remove this thread O(1)
                        sem->count++;
                        if( !copy->lock ) {
                                unlock( sem->lock );
                                #if !defined( __CFA_NO_STATISTICS__ )
                                        kernelTLS.this_stats = copy->t->curr_cluster->stats;
                                #endif
                                unpark( copy->t );
                } else {
                        add_(*copy->lock, copy->t);                     // call lock's add_
                }
            }
            unlock( sem->lock );
        }

        void alarm_node_sem_cast( alarm_node_t & a ) {
                timeout_handler( (alarm_node_semaphore(L) &)a );
        }

        void handle_P(base_semaphore(L) & this, info_thread( L ) & i ) with( this ) {
                lock( lock __cfaabi_dbg_ctx2 );
                if ( count <= 0) {
                        append( blocked_threads, &i );

                        if (!is_binary) count--;

                        i.listed = true;

                        size_t recursion_count;
                        if (i.lock) {
                                recursion_count = get_recursion_count( *i.lock );
                                remove_( *i.lock );
                        }

                        unlock( lock );
                        park( );

                        if (i.lock) set_recursion_count( *i.lock, recursion_count );
                } else {
                        if (i.lock) {
                                size_t recursion_count = get_recursion_count( *i.lock );
                                remove_( *i.lock );
                                add_( *i.lock, i.t );
                                set_recursion_count( *i.lock, recursion_count );
                        }
                        count--;
                        unlock( lock );
                }
        }

        void handle_P_timeout(base_semaphore(L) & this, info_thread( L ) & i, Time time) with( this ) {
                lock( lock __cfaabi_dbg_ctx2 );
                if ( count <= 0) {
                        append( blocked_threads, &i );

                        if (!is_binary) count--;

                        info_thread(L) * queue_ptr = &i;
                        i.listed = true;

                        alarm_node_semaphore(L) node_wrap = { i.t, time, 0`s, alarm_node_sem_cast };
                        node_wrap.sem = &this;
                        node_wrap.i = &queue_ptr;

                        register_self( &node_wrap.alarm_node );

                        size_t recursion_count;
                        if (i.lock) {
                                recursion_count = get_recursion_count( *i.lock );
                                remove_( *i.lock );
                        }

                        unlock( lock );
                        park( );

                        if (i.lock) set_recursion_count( *i.lock, recursion_count );
                } else {
                        count--;
                        unlock( lock );
                }
        }

        void P(base_semaphore(L) & this) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread };
                handle_P(this, i);
        }

        void P(base_semaphore(L) & this, uintptr_t info) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread, info };
                handle_P(this, i);
        }

        void P(base_semaphore(L) & this, Duration duration) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread };
                handle_P_timeout(this, i, __kernel_get_time() + duration);
        }

        void P(base_semaphore(L) & this, uintptr_t info, Duration duration) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread, info };
                handle_P_timeout(this, i, __kernel_get_time() + duration);
        }

        void P(base_semaphore(L) & this, Time time) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread };
                handle_P_timeout(this, i, time);
        }

        void P(base_semaphore(L) & this, uintptr_t info, Time time) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread, info };
                handle_P_timeout(this, i, time);
        }

        void P(base_semaphore(L) & this, L & l ) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread };
                i.lock = &l;
                handle_P(this, i);
        }

        void P(base_semaphore(L) & this, L & l, uintptr_t info) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread, info };
                i.lock = &l;
                handle_P(this, i);
        }

        void P(base_semaphore(L) & this, L & l, Duration duration ) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread };
                i.lock = &l;
                handle_P_timeout(this, i, __kernel_get_time() + duration);
        }

        void P(base_semaphore(L) & this, L & l, uintptr_t info, Duration duration) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread, info };
                i.lock = &l;
                handle_P_timeout(this, i, __kernel_get_time() + duration);
        }

        void P(base_semaphore(L) & this, L & l, Time time) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread };
                i.lock = &l;
                handle_P_timeout(this, i, time);
        }

        void P(base_semaphore(L) & this, L & l, uintptr_t info, Time time) with( this ) {
                info_thread( L ) i = { kernelTLS.this_thread, info };
                i.lock = &l;
                handle_P_timeout(this, i, time);
        }

        bool tryP(base_semaphore(L) & this) with( this ) {
                lock( lock __cfaabi_dbg_ctx2 );
                if ( count <= 0) {
                        unlock( lock );
                        return false;
                } else {
                        count--;
                }
                unlock( lock );
        }

        void V(base_semaphore(L) & this) with( this ) {
                lock( lock __cfaabi_dbg_ctx2 );
                if( count < 0) {
                        info_thread(L) * i = pop_head( blocked_threads );
                        i->listed = false;
                        count++;
                        if ( i != 0p ) {
                                if (i->lock) {
                                        add_(*i->lock, i->t);
                                } else {
                                        unpark(i->t);
                                }
                        }
                } else if (!is_binary || count == 0) {
                        count++;
                } else {
                        fprintf( stderr, "A binary semaphore was V'd when it was already at 1" );
                }
                unlock( lock );
        }


        // TODO: Should we be able to V a binary semaphore multiple times to wake up multiple thds?
        // right now we can't
        void V(base_semaphore(L) & this, int times) with( this ) {
                assert( times > 0 );
                lock( lock __cfaabi_dbg_ctx2 );
                while ( count < 0 && times > 0 ) {
                        info_thread(L) * i = pop_head( blocked_threads );
                        i->listed = false;
                        count++;
                        if ( i != 0p ) {
                                if (i->lock) {
                                        add_(*i->lock, i->t);
                                } else {
                                        unpark(i->t);
                                }
                        }
                        times--;
                }
                if(     !is_binary ) {
                        count += times;
                } else if (count == 0 && times > 1) {
                        fprintf( stderr, "A binary semaphore was V'd when it was already at 1" );
                } else {
                        count++;
                }
                unlock( lock );
        }

        // void ?++(base_semaphore(L) & this) with( this ) {
        //      V(this);
        // }

        // void ?--(base_semaphore(L) & this) with( this ) {
        //      P(this);
        // }

        // void ?`V(base_semaphore(L) & this) with( this ) {
        //      V(this);
        // }

        // void ?`P(base_semaphore(L) & this) with( this ) {
        //      P(this);
        // }

        uintptr_t front(base_semaphore(L) & this) with( this ) {
                info_thread(L) *front = peek(blocked_threads);
                if(!blocked_threads) return 0;
                return front->info;
        }

        bool empty(base_semaphore(L) & this) with( this ) {
                return blocked_threads ? false : true;
        }

        int counter(base_semaphore(L) & this) with( this ) {
                return count;
        }

        // these are just to allow the semaphore to be a part of the is_blocking_lock trait
        // they do nothing
        void set_recursion_count( base_semaphore(L) & this, size_t recursion ) with( this ) {
                // default
        }

        size_t get_recursion_count( base_semaphore(L) & this ) with( this ) {
                return 0;
        }

        ////////////////////////////////////////////////////////////////////////////////
        // These extras are needed since the inheritance is broken with traits
        // normally I'd cast to a semaphore & to call the parent but theres no need
        // since these routines are so simple
        ////////////////////////////////////////////////////////////////////////////////

        void set_recursion_count( binary_semaphore(L) & this, size_t recursion ) with( this ) {
                // default
        }

        size_t get_recursion_count( binary_semaphore(L) & this ) with( this ) {
                return 0;
        }

        void set_recursion_count( counting_semaphore(L) & this, size_t recursion ) with( this ) {
                // default
        }

        size_t get_recursion_count( counting_semaphore(L) & this ) with( this ) {
                return 0;
        }

        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
}

thread T1 {};
thread T2 {};

// counting_semaphore( ) s0, s1;

// void main( T1 & this ) {
//      printf("T1 start\n");
//      V(s1);
//      P(s0);
//      P(s0);
//      V(s1, 2);
        
//      printf("T1 done\n");
// }

// void main( T2 & this ) {
//      printf("T2 start\n");
//      V(s0);
//      P(s1);
//      P(s1, s0);
//      P(s1);
//      printf("T2 done\n");
// }

int main() {
        printf("start\n");
        // processor p[2];
        // {
        //      T1 t1;
        //      T2 t2;
        // }
        printf("done\n");
}