#pragma once

#ifndef INC_SRT_SYNC_H

#define INC_SRT_SYNC_H

#include "platform_sys.h"

#include "srt_attr_defs.h"

#include <cstdlib>

#include <limits>

#ifdef SRT_ENABLE_STDCXX_SYNC

#include <chrono>

#include <thread>

#include <mutex>

#include <condition_variable>

#include <atomic>

#ifdef SRT_ENABLE_STDCXX_SHARED_MUTEX

#include <shared_mutex>

#endif

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_STDCXX_STEADY

#define SRT_SYNC_CLOCK_STR "STDCXX_STEADY"

#else

#include <pthread.h>

#ifdef IA32

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_IA32_RDTSC

#define SRT_SYNC_CLOCK_STR "IA32_RDTSC"

#elif defined(IA64)

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_IA64_ITC

#define SRT_SYNC_CLOCK_STR "IA64_ITC"

#elif defined(AMD64)

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_AMD64_RDTSC

#define SRT_SYNC_CLOCK_STR "AMD64_RDTSC"

#elif defined(_WIN32)

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_WINQPC

#define SRT_SYNC_CLOCK_STR "WINQPC"

#elif TARGET_OS_MAC

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_MACH_ABSTIME

#define SRT_SYNC_CLOCK_STR "MACH_ABSTIME"

#elif defined(SRT_ENABLE_MONOTONIC_CLOCK)

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_GETTIME_MONOTONIC

#define SRT_SYNC_CLOCK_STR "GETTIME_MONOTONIC"

#else

#define SRT_SYNC_CLOCK SRT_SYNC_CLOCK_POSIX_GETTIMEOFDAY

#define SRT_SYNC_CLOCK_STR "POSIX_GETTIMEOFDAY"

#endif

#endif // SRT_ENABLE_STDCXX_SYNC

#ifndef SRT_BUSY_WAITING

#define SRT_BUSY_WAITING 0

#endif

#include "srt.h"

#include "utilities.h"

#include "atomic_clock.h"

#include "ofmt.h"

#ifdef SRT_ENABLE_THREAD_DEBUG

#include <set>

#endif

namespace srt

{

class CUDTException; // defined in common.h

namespace sync

{

#if SRT_ENABLE_STDCXX_SYNC

template <class Clock>

using Duration = std::chrono::duration<Clock>;

#else

template <class Clock>

class Duration

};

#endif // SRT_ENABLE_STDCXX_SYNC

#if SRT_ENABLE_STDCXX_SYNC

using steady_clock = std::chrono::steady_clock;

template <class Clock, class Duration = typename Clock::duration>

using time_point = std::chrono::time_point<Clock, Duration>;

template <class Clock>

using TimePoint = std::chrono::time_point<Clock>;

template <class Clock, class Duration = typename Clock::duration>

inline bool is_zero(const time_point<Clock, Duration> &tp)

{

return tp.time_since_epoch() == Clock::duration::zero();

}

inline bool is_zero(const steady_clock::time_point& t)

{

return t == steady_clock::time_point();

}

#else

template <class Clock>

class TimePoint;

class steady_clock

};

template <class Clock>

class TimePoint

};

template <>

Duration<steady_clock> TimePoint<steady_clock>::time_since_epoch() const;

inline Duration<steady_clock> operator*(const int& lhs, const Duration<steady_clock>& rhs)

{

return rhs * lhs;

}

#endif // SRT_ENABLE_STDCXX_SYNC

int clockSubsecondPrecision();

#if SRT_ENABLE_STDCXX_SYNC

inline long long count_microseconds(const steady_clock::duration &t)

{

return std::chrono::duration_cast<std::chrono::microseconds>(t).count();

}

inline long long count_microseconds(const steady_clock::time_point tp)

{

return std::chrono::duration_cast<std::chrono::microseconds>(tp.time_since_epoch()).count();

}

inline long long count_milliseconds(const steady_clock::duration &t)

{

return std::chrono::duration_cast<std::chrono::milliseconds>(t).count();

}

inline long long count_seconds(const steady_clock::duration &t)

{

return std::chrono::duration_cast<std::chrono::seconds>(t).count();

}

inline steady_clock::duration microseconds_from(int64_t t_us)

{

return std::chrono::microseconds(t_us);

}

inline steady_clock::duration milliseconds_from(int64_t t_ms)

{

return std::chrono::milliseconds(t_ms);

}

inline steady_clock::duration seconds_from(int64_t t_s)

{

return std::chrono::seconds(t_s);

}

#else

int64_t count_microseconds(const steady_clock::duration& t);

int64_t count_milliseconds(const steady_clock::duration& t);

int64_t count_seconds(const steady_clock::duration& t);

Duration<steady_clock> microseconds_from(int64_t t_us);

Duration<steady_clock> milliseconds_from(int64_t t_ms);

Duration<steady_clock> seconds_from(int64_t t_s);

inline bool is_zero(const TimePoint<steady_clock>& t)

{

return t == TimePoint<steady_clock>();

}

#endif // SRT_ENABLE_STDCXX_SYNC

#ifdef SRT_ENABLE_STDCXX_SYNC

typedef std::system_error CThreadException;

using CThread = std::thread;

namespace this_thread = std::this_thread;

#else // pthreads wrapper version

typedef CUDTException CThreadException;

class CThread

};

template <class Stream>

inline Stream& operator<<(Stream& str, const CThread::id& cid)

{

#if defined(_WIN32) && (defined(PTW32_VERSION) || defined (__PTW32_VERSION))

// This is a version specific for pthread-win32 implementation

// Here pthread_t type is a structure that is not convertible

// to a number at all.

return str << pthread_getw32threadid_np(cid.value);

#else

return str << cid.value;

#endif

}

namespace this_thread

{

const inline CThread::id get_id() { return CThread::id (pthread_self()); }

inline void sleep_for(const steady_clock::duration& t)

}

}

#endif

#ifdef SRT_ENABLE_STDCXX_SYNC

typedef void* (&ThreadFunc) (void*);

bool StartThread(CThread& th, ThreadFunc&& f, void* args, const std::string& name);

#else

bool StartThread(CThread& th, void* (*f) (void*), void* args, const std::string& name);

#endif

inline bool CheckAffinity(CThread::id id)

{

return this_thread::get_id() == id;

}

inline bool this_thread_is(const CThread& th)

{

return this_thread::get_id() == th.get_id();

}

void SetThreadLocalError(const CUDTException& e);

CUDTException& GetThreadLocalError();

#if SRT_ENABLE_STDCXX_SYNC

using Mutex SRT_TSA_CAPABILITY("mutex") = std::mutex;

using UniqueLock = std::unique_lock<std::mutex>;

using ScopedLock = std::lock_guard<std::mutex>;

#else

class SRT_TSA_CAPABILITY("mutex") Mutex

{

friend class SyncEvent;

explicit Mutex();

~Mutex();

int lock() SRT_TSA_WILL_LOCK();

int unlock() SRT_TSA_WILL_UNLOCK();

/// @return true if the lock was acquired successfully, otherwise false

bool try_lock() SRT_TSA_WILL_TRY_LOCK(true);

// TODO: To be removed with introduction of the CEvent.

pthread_mutex_t& ref() { return m_mutex; }

pthread_mutex_t m_mutex;

};

class SRT_TSA_SCOPED_CAPABILITY ScopedLock

{

SRT_TSA_WILL_LOCK(m)

explicit ScopedLock(Mutex& m)

}

SRT_TSA_WILL_UNLOCK()

~ScopedLock() { m_mutex.unlock(); }

Mutex& m_mutex;

};

class SRT_TSA_SCOPED_CAPABILITY UniqueLock

{

friend class SyncEvent;

int m_iLocked;

Mutex& m_Mutex;

SRT_TSA_WILL_LOCK(m)

explicit UniqueLock(Mutex &m);

SRT_TSA_WILL_UNLOCK()

~UniqueLock();

SRT_TSA_WILL_LOCK()

void lock();

SRT_TSA_WILL_UNLOCK()

void unlock();

SRT_TSA_RETURN_CAPABILITY(m_Mutex)

Mutex* mutex(); // reflects C++11 unique_lock::mutex()

};

#endif // SRT_ENABLE_STDCXX_SYNC

inline void enterCS(Mutex& m)

SRT_TSA_NEEDS_NONLOCKED(m)

SRT_TSA_WILL_LOCK(m)

{ m.lock(); }

inline bool tryEnterCS(Mutex& m)

SRT_TSA_NEEDS_NONLOCKED(m)

SRT_TSA_WILL_TRY_LOCK(true, m)

{ return m.try_lock(); }

inline void leaveCS(Mutex& m)

SRT_TSA_NEEDS_LOCKED(m)

SRT_TSA_WILL_UNLOCK(m)

{ m.unlock(); }

class InvertedLock

};

inline void setupMutex(Mutex&, const char*) {}

inline void releaseMutex(Mutex&) {}

class Condition

};

inline void setupCond(Condition& cv, const char*, bool sanitize = false) { cv.init(); cv.sanitize(sanitize); }

inline void resetCond(Condition& cv) { cv.reset(); }

inline void releaseCond(Condition& cv) { cv.destroy(); }

#if defined(SRT_ENABLE_STDCXX_SHARED_MUTEX)

using SharedMutex SRT_TSA_CAPABILITY("mutex") = std::shared_mutex;

#else

class SRT_TSA_CAPABILITY("mutex") SharedMutex

{

SharedMutex();

~SharedMutex();

/// Acquire the lock for writing purposes. Only one thread can acquire this lock at a time

/// Once it is locked, no reader can acquire it

void lock() SRT_TSA_WILL_LOCK();

bool try_lock() SRT_TSA_WILL_TRY_LOCK(true);

void unlock() SRT_TSA_WILL_UNLOCK();

/// Acquire the lock if no writer already has it. For read purpose only

/// Several readers can lock this at the same time.

void lock_shared() SRT_TSA_WILL_LOCK_SHARED();

bool try_lock_shared() SRT_TSA_WILL_TRY_LOCK_SHARED(true);

void unlock_shared() SRT_TSA_WILL_UNLOCK_SHARED();

int getReaderCount() const;

#ifdef SRT_ENABLE_THREAD_DEBUG

CThread::id exclusive_owner() const { return m_ExclusiveOwner; }

bool shared_owner(CThread::id i) const { return m_SharedOwners.count(i); }

#else

// XXX NOT IMPLEMENTED. This returns true if ANY THREAD has

// made a shared lock in order to fire assertion only if the

// lock was NOT applied at all (whether by this thread or any other)

bool shared_owner(CThread::id) const { return m_iCountRead; }

#endif

Condition m_LockWriteCond;

Condition m_LockReadCond;

mutable Mutex m_Mutex;

int m_iCountRead;

bool m_bWriterLocked;

#ifdef SRT_ENABLE_THREAD_DEBUG

CThread::id m_ExclusiveOwner; // For debug support

std::set<CThread::id> m_SharedOwners;

#endif

};

#endif

inline void enterCS(SharedMutex& m) SRT_TSA_WILL_LOCK(m) { m.lock(); }

inline bool tryEnterCS(SharedMutex& m) SRT_TSA_WILL_TRY_LOCK(true, m) { return m.try_lock(); }

inline void leaveCS(SharedMutex& m) SRT_TSA_WILL_UNLOCK(m) { m.unlock(); }

inline void setupMutex(SharedMutex&, const char*) {}

inline void releaseMutex(SharedMutex&) {}

class SRT_TSA_SCOPED_CAPABILITY ExclusiveLock

{

SRT_TSA_WILL_LOCK(m)

explicit ExclusiveLock(SharedMutex& m)

}

SRT_TSA_WILL_UNLOCK()

~ExclusiveLock() { m_mutex.unlock(); }

SharedMutex& m_mutex;

};

class SRT_TSA_SCOPED_CAPABILITY SharedLock

{

explicit SharedLock(SharedMutex& m)

SRT_TSA_WILL_LOCK_SHARED(m)

}

~SharedLock()

SRT_TSA_WILL_UNLOCK_GENERIC() // Using generic because TSA somehow doesn't understand it was locked shared

{ m_mtx.unlock_shared(); }

SharedMutex& m_mtx;

};

template <class T>

class CSharedObjectPtr : public SharedMutex

};

class CSync