source: libcfa/src/concurrency/locks.hfa@ e43aa14

#pragma once

#include <stdbool.h>

#include "bits/algorithm.hfa"
#include "bits/locks.hfa"
#include "bits/sequence.hfa"
#include "bits/containers.hfa"

#include "invoke.h"

#include "time_t.hfa"
#include "time.hfa"
#include <sys/time.h>
#include "alarm.hfa"

///////////////////////////////////////////////////////////////////
//// is_blocking_lock
///////////////////////////////////////////////////////////////////

trait is_blocking_lock(dtype L | sized(L)) {
        void add_( L &, struct $thread * );             // For synchronization locks to use when acquiring
        void remove_( L & );    // For synchronization locks to use when releasing
        size_t get_recursion_count( L & ); // to get recursion count for cond lock to reset after waking
        void set_recursion_count( L &, size_t recursion ); // to set recursion count after getting signalled;
};

///////////////////////////////////////////////////////////////////
//// info_thread
///////////////////////////////////////////////////////////////////

forall(dtype L | is_blocking_lock(L)) {
        struct info_thread {
                inline Seqable;
                struct $thread * t;
                uintptr_t info;
                L * lock;
                bool listed;                                    // true if info_thread is on queue, false otherwise;
        };


        void ?{}( info_thread(L) & this, $thread * t );
        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
        void ^?{}( info_thread(L) & this );
}

///////////////////////////////////////////////////////////////////
//// Blocking Locks
///////////////////////////////////////////////////////////////////

// struct lock_thread {
//      struct $thread * t;
//      lock_thread * next;
// };

// void ?{}( lock_thread & this, struct $thread * thd );
// void ^?{}( lock_thread & this );

// lock_thread *& get_next( lock_thread & );

struct blocking_lock {
        // Spin lock used for mutual exclusion
        __spinlock_t lock;

        // List of blocked threads
        __queue_t( $thread ) blocked_threads;

        // Count of current blocked threads
        size_t wait_count;

        // Flag if the lock allows multiple acquisition
        bool multi_acquisition;

        // Flag if lock can be released by non owner
        bool strict_owner;

        // Current thread owning the lock
        struct $thread * owner;

        // Number of recursion level
        size_t recursion_count;
};

struct single_acquisition_lock {
        inline blocking_lock;
};

struct owner_lock {
        inline blocking_lock;
};

struct multiple_acquisition_lock {
        inline blocking_lock;
};

void ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner );
void ^?{}( blocking_lock & this );

void ?{}( single_acquisition_lock & this );
void ^?{}( single_acquisition_lock & this );

void ?{}( owner_lock & this );
void ^?{}( owner_lock & this );

void ?{}( multiple_acquisition_lock & this );
void ^?{}( multiple_acquisition_lock & this );

void lock( blocking_lock & this );
bool try_lock( blocking_lock & this );
void unlock( blocking_lock & this );
void add_( blocking_lock & this, struct $thread * t );
void remove_( blocking_lock & this );
size_t wait_count( blocking_lock & this );
void set_recursion_count( blocking_lock & this, size_t recursion );
size_t get_recursion_count( blocking_lock & this );

void lock( single_acquisition_lock & this );
void unlock( single_acquisition_lock & this );
void add_( single_acquisition_lock & this, struct $thread * t );
void remove_( single_acquisition_lock & this );
void set_recursion_count( single_acquisition_lock & this, size_t recursion );
size_t get_recursion_count( single_acquisition_lock & this );

void lock( owner_lock & this );
void unlock( owner_lock & this );
void add_( owner_lock & this, struct $thread * t );
void remove_( owner_lock & this );
void set_recursion_count( owner_lock & this, size_t recursion );
size_t get_recursion_count( owner_lock & this );

void lock( multiple_acquisition_lock & this );
void unlock( multiple_acquisition_lock & this );
void add_( multiple_acquisition_lock & this, struct $thread * t );
void remove_( multiple_acquisition_lock & this );
void set_recursion_count( multiple_acquisition_lock & this, size_t recursion );
size_t get_recursion_count( multiple_acquisition_lock & this );

///////////////////////////////////////////////////////////////////
//// Synchronization Locks
///////////////////////////////////////////////////////////////////
forall(dtype L | is_blocking_lock(L)) {
        struct condition_variable {
                // Spin lock used for mutual exclusion
                __spinlock_t lock;

                info_thread(L) * last_thread;

                // List of blocked threads
                Sequence( info_thread(L) ) blocked_threads;

                // Count of current blocked threads
                int count;
        };

        void ?{}( condition_variable(L) & this );
        void ^?{}( condition_variable(L) & this );

        struct alarm_node_wrap {
                alarm_node_t alarm_node;

                condition_variable(L) * cond;

                info_thread(L) * i;
        };

        void ?{}( alarm_node_wrap(L) & this, Time alarm, Duration period, Alarm_Callback callback );
        void ^?{}( alarm_node_wrap(L) & this );

        void alarm_node_callback( alarm_node_wrap(L) & this );

        void alarm_node_wrap_cast( alarm_node_t & a );

        bool notify_one( condition_variable(L) & this );
        bool notify_all( condition_variable(L) & this );

        uintptr_t front( condition_variable(L) & this );

        bool empty( condition_variable(L) & this );
        int counter( condition_variable(L) & this );

        // TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
        void wait( condition_variable(L) & this );
        void wait( condition_variable(L) & this, uintptr_t info );
        void wait( condition_variable(L) & this, Duration duration );
        void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
        void wait( condition_variable(L) & this, Time time );
        void wait( condition_variable(L) & this, uintptr_t info, Time time );

        void wait( condition_variable(L) & this, L & l );
        void wait( condition_variable(L) & this, L & l, uintptr_t info );
        void wait( condition_variable(L) & this, L & l, Duration duration );
        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
        void wait( condition_variable(L) & this, L & l, Time time );
        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
}