BeThread.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once


#include "BeCriticalSection.h"
#include "BeAtomic.h"

#if defined (_WIN32) && defined(_MANAGED)
    //=======================================================================================
    //
    // BEMUTEX_DATA_ARRAY_LENGTH = sizeof (std::recursive_mutex) / sizeof (void*)
    // BECONDITIONVARIABLE_DATA_ARRAY_LENGTH = sizeof (std::condition_variable_any) / sizeof (void*)
    // Array of void* is used to force pointer type alignment
    //=======================================================================================
    #if (_MSC_VER >= 1900)
        #if defined(_M_X64)
            #define BEMUTEX_DATA_ARRAY_LENGTH (80 / sizeof(void*))
            #define BECONDITIONVARIABLE_DATA_ARRAY_LENGTH (88 / sizeof(void*))
        #else
            #define BEMUTEX_DATA_ARRAY_LENGTH (48 / sizeof(void*))
            #define BECONDITIONVARIABLE_DATA_ARRAY_LENGTH (48 / sizeof(void*))
        #endif
    #else
        #define BEMUTEX_DATA_ARRAY_LENGTH 1
        #define BECONDITIONVARIABLE_DATA_ARRAY_LENGTH 2
    #endif
#else
    //=======================================================================================
    // Sane platforms...
    //=======================================================================================
    #include <mutex>
    #include <condition_variable>
    #define BEMUTEX_DATA_ARRAY_LENGTH sizeof(std::recursive_mutex) / sizeof(void*)
    #define BECONDITIONVARIABLE_DATA_ARRAY_LENGTH sizeof(std::condition_variable_any) / sizeof(void*)
#endif


BEGIN_BENTLEY_NAMESPACE



//=======================================================================================
//  @bsiclass                                                     Bentley Systems
//=======================================================================================
struct BeMutex
{
private:
    BeMutex(BeMutex const&) = delete;
    BeMutex& operator=(BeMutex const&) = delete;
    void* m_osMutex[BEMUTEX_DATA_ARRAY_LENGTH];

public:
    BENTLEYDLL_EXPORT BeMutex();
    BENTLEYDLL_EXPORT ~BeMutex();

    BENTLEYDLL_EXPORT void lock();
    void Enter() {lock();}

    BENTLEYDLL_EXPORT void unlock();
    void Leave() {unlock();}
};

//=======================================================================================
//  @bsiclass                                                     Bentley Systems
//=======================================================================================
struct BeMutexHolder
{
private:
    BeMutexHolder(BeMutexHolder const&) = delete;
    BeMutexHolder& operator=(BeMutexHolder const&) = delete;

    BeMutex* m_mutex;

    bool m_owns;

public:
    enum class Lock : bool {No=false, Yes=true};

    BENTLEYDLL_EXPORT BeMutexHolder(BeMutex& mutex, Lock lock=Lock::Yes);

    BENTLEYDLL_EXPORT ~BeMutexHolder();

    BeMutex* GetMutex() {return m_mutex;}
    BENTLEYDLL_EXPORT void unlock();
    BENTLEYDLL_EXPORT void lock();
    BENTLEYDLL_EXPORT bool owns_lock();
};

//=======================================================================================
//  @bsiclass                                                     Bentley Systems
//=======================================================================================
struct IConditionVariablePredicate
{
    virtual bool _TestCondition(struct BeConditionVariable &cv) = 0;
};

//=======================================================================================
//  @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  BeConditionVariable
{
private:
    void* m_osCV[BECONDITIONVARIABLE_DATA_ARRAY_LENGTH];
    mutable BeMutex m_mutex;
    BeConditionVariable(BeConditionVariable const&) = delete;
    BeConditionVariable& operator=(BeConditionVariable const&) = delete;

public:
    BENTLEYDLL_EXPORT void InfiniteWait(BeMutexHolder& holder);
    BENTLEYDLL_EXPORT bool RelativeWait(BeMutexHolder& holder, uint32_t timeoutMillis);

    static const uint32_t Infinite = 0xffffffff;

    BENTLEYDLL_EXPORT BeConditionVariable();
    BENTLEYDLL_EXPORT ~BeConditionVariable();

    // Get the mutex
    BeMutex& GetMutex() const {return m_mutex;}

    BENTLEYDLL_EXPORT bool ProtectedWaitOnCondition(BeMutexHolder&, IConditionVariablePredicate* predicate, uint32_t timeoutMillis);

    bool WaitOnCondition(IConditionVariablePredicate* predicate, uint32_t timeoutMillis)
        {
        BeMutexHolder holder(m_mutex);
        return ProtectedWaitOnCondition(holder, predicate, timeoutMillis);
        }

    BENTLEYDLL_EXPORT void notify_one();
    BENTLEYDLL_EXPORT void notify_all();
};




/*=================================================================================**/

struct  BeThreadUtilities
    {
    typedef unsigned (__stdcall *T_ThreadStart)(void*);

    BENTLEYDLL_EXPORT static uintptr_t StartNewThread (int stackSize, T_ThreadStart startAddr, void* arg);

    BENTLEYDLL_EXPORT static void SetCurrentThreadName(Utf8CP newName);
    
    BENTLEYDLL_EXPORT static intptr_t GetCurrentThreadId();

    BENTLEYDLL_EXPORT static void BeSleep (UInt32 millis);
    };


END_BENTLEY_NAMESPACE