Go to the documentation of this file.
29 #if !defined( __INOS_SYN_H )
40 #define INOS_NO_WAIT 0x00000000 // don't wait
41 #define INOS_WAIT_FOREVER 0xFFFFFFFF // wait forever
46 #ifdef INOS_CACHE_LOCK_SUPPORT
47 #define ICACHE __attribute__ ((section (".icache")))
48 #define DCACHE __attribute__ ((section (".dcache")))
82 uint32 aInitialCount=0,
102 ICACHE
virtual uint32
Wait(uint32 aTimeout=INOS_WAIT_FOREVER);
106 ICACHE
virtual void Signal() { iSignal(
false); }
126 virtual void Reset();
131 {
return m_Lock.GetAddr(); };
135 virtual bool UsesPolling()
const {
return false;};
138 return this == i_pSync;
141 #if defined(INOS_SYNCGUARD)
153 friend class CINOSScheduler;
166 #if defined(INOS_SYNCGUARD)
167 uint32 m_uReferenced{};
168 uint32 m_uReferencedByParent{};
173 int operator < (
const CINOSSync& aSync)
const
175 int operator == (
const CINOSSync& aSync)
const
177 int operator < (
const char* aName)
const
178 {
return (strcmp(
m_pName, aName)<0);}
179 int operator == (
const char* aName)
const
180 {
return (strcmp(
m_pName, aName)==0);}
185 ICACHE
virtual bool Signaled(
CINOSSync*& aChild);
187 virtual CINOSSyncNode* GetNode() {
return m_pNode;};
189 virtual void SetNode(CINOSSyncNode* aNode) {
m_pNode = aNode;};
197 iSignal(
true, auMsr);
207 void iSignal(
bool abAlreadyLocked, uint32 uMsr = 0);
217 class CINOSExceptionCleanup;
262 ICACHE
virtual uint32
Wait(uint32 aTimeout=INOS_WAIT_FOREVER)
override;
266 ICACHE
virtual uint32
Wait(
CINOSSync*& aChild, uint32 aTimeout=INOS_WAIT_FOREVER);
270 virtual void Reset()
override;
274 virtual bool UsesPolling()
const override {
return m_bUsesPolling;};
280 void SetBus(
CINOSBus* apBus) { m_pBus = apBus; }
284 friend class CINOSSyncNode;
288 CINOSSyncNode* pFirstChild;
289 CINOSSyncNode* pLastChild;
292 CINOSExceptionCleanup* pCleanup;
303 ICACHE
virtual bool Signaled(
CINOSSync*& aChild)
override;
329 CINOSSyncNode* pNext;
332 #ifndef INOS_MULTICORE
333 CINOSSyncNode* pNextGroup;
345 ICACHE
void WakeUp();
388 template<
class Rep,
class Period >
389 EStatus
WaitFor(std::unique_lock<CINOSMutex>& lock,
390 const std::chrono::duration<Rep, Period>& rel_time)
392 uint32 waitUs = std::chrono::duration_cast<std::chrono::microseconds>(rel_time).count();
393 const uint32 uWaitTime = DoWait(lock, waitUs);
394 return (uWaitTime == 0) ? eTimeout : eNoTimeout;
399 template<
class Rep,
class Period,
class Predicate >
400 bool WaitFor( std::unique_lock<CINOSMutex>& lock,
401 const std::chrono::duration<Rep, Period>& rel_time,
403 uint32 waitUs = checked_static_cast<uint32>(std::chrono::duration_cast<std::chrono::microseconds>(rel_time).count());
405 uint32 uWaitTime = DoWait(lock, waitUs);
410 waitUs = (waitUs - uWaitTime) > 0 ? waitUs - uWaitTime : 0;
417 void Wait( std::unique_lock<CINOSMutex>& lock ) {
423 template<
class Predicate >
424 void wait( std::unique_lock<CINOSMutex>& lock, Predicate pred ) {
440 uint32 DoWait(std::unique_lock<CINOSMutex>& lock, uint32 auTimeout = INOS_WAIT_FOREVER);
467 const char* apName = 0,
468 uint32 auInitialCount = 1,
469 uint32 auMaxCount = 0xffffffff
482 ICACHE uint32
Request(uint32 aTimeout=INOS_WAIT_FOREVER);
496 {
return m_uMaxCount; }
524 CINOSQueue(
const char* apName, uint32 auNumber, uint32 auSize);
538 ICACHE uint32
Put(
void* aData, uint32 aTimeout=INOS_WAIT_FOREVER, uint32 auFlags=0);
547 ICACHE uint32
Get(
void* aData, uint32 aTimeout=INOS_WAIT_FOREVER);
556 void Inquiry(
void* aData, uint32& aCountOfElements);
568 bool InquiryAt(
void* aData, uint32 auIndex);
638 bool Access(
void*&ptrData, uint32 auIndex);
648 eFlgOverflowCheck = 0x00000001,
649 eFlgOverflowFatal = 0x00000002,
650 eFlgAccess = 0x00000004,
651 eFlgUnique = 0x00000008,
674 #include <cinostaskqueue.h>
688 uint32 aInitialCount=0,
706 #ifndef INOS_NO_BIT_EVENT_SUPPORT
724 virtual uint32
Wait(uint32 aTimeout=INOS_WAIT_FOREVER)
override ;
726 virtual void Signal()
override ;
728 virtual void Reset()
override ;
731 virtual bool UsesPolling()
const override {
return m_bUsesPolling;};
741 CINOSExceptionCleanup* m_pCleanup;
749 virtual bool Signaled(
CINOSSync*& aChild)
override;
751 virtual CINOSSyncNode* GetNode()
override {
return m_pEvent->GetNode();};
753 virtual void SetNode(CINOSSyncNode* aNode)
override {m_pEvent->SetNode(aNode);};
781 virtual uint32
Wait(uint32 aTimeout=INOS_WAIT_FOREVER)
override ;
783 virtual void Signal()
override ;
785 virtual void Reset()
override ;
788 virtual bool UsesPolling()
const override {
return m_bUsesPolling;};
798 CINOSExceptionCleanup* m_pCleanup;
806 virtual bool Signaled(
CINOSSync*& aChild)
override ;
808 virtual CINOSSyncNode* GetNode()
override {
return m_pEvent->GetNode();};
810 virtual void SetNode(CINOSSyncNode* aNode)
override {m_pEvent->SetNode(aNode);};
823 #ifndef INOS_NO_1MS_SUPPORT
846 void Reset(uint32 aTime=eUsePreviousTime);
853 void Start(uint32 aTime=eUsePreviousTime);
861 void iRemoveHandler();
865 uint32 mWaitTime = eEventDisabled;
868 CINOSExceptionCleanup* pCleanup =
nullptr;
888 class CINOSSyncObjects
902 TINOSNameBalancedBinaryTree<CINOSSync>* pSyncObjects;
914 template<
typename TLock>
923 m_Lock(aLock), m_bLocked(false)
925 m_bLocked = (m_Lock.Request() != 0);
930 m_Lock(aLock), m_bLocked(false)
932 m_bLocked = (m_Lock.Request(auTimeout) != 0);
935 if (m_bLocked) m_Lock.Release();
937 bool IsLocked()
const {
972 const char* apParentName,
973 const char* apBaseName,
974 int32 aiInitialCount = 0,
975 void* apHandlerObj = NULL,
976 void* apHandlerFunc = NULL
1016 void* m_pHandlerFunc;
1038 std::unique_lock<CINOSMutex> lock(m_Mutex);
1039 while (HasForeignWriter()) {
1040 m_Unlocked.
wait(lock, [
this]() {
return !HasForeignWriter(); });
1046 std::unique_lock<CINOSMutex> lock(m_Mutex);
1048 if (m_uReaders == 0)
1056 std::unique_lock<CINOSMutex> lock(m_Mutex);
1057 while (HasForeignWriter() || HasReaders()) {
1058 m_Unlocked.
wait(lock, [
this]() {
return !(HasForeignWriter() || HasReaders()); });
1065 std::unique_lock<CINOSMutex> lock(m_Mutex);
1067 if (m_nWriter == 0) {
1068 m_pWriter =
nullptr;
1073 bool HasReaders()
const {
1074 return m_uReaders > 0;
1076 bool HasForeignWriter()
const {
1077 const bool bHasWriter = m_nWriter > 0;
1078 const bool bWriterIsMe =
ActualTask() == m_pWriter;
1079 return bHasWriter && !bWriterIsMe;
1083 size_t m_uReaders{};
1086 size_t m_nWriter{0};
1108 m_Lock.WriteUnlock();
1125 m_Lock.ReadUnlock();
1134 extern CINOSSyncObjects* pINOSSyncObjects;
1136 #endif // __INOS_SYN_H
void WriteUnlock()
Definition: inos_syn.h:1064
Definition: cinosmutex.h:35
Definition: cinosbus.h:562
Definition: inos_syn.h:1032
bool Access(void *&ptrData, uint32 auIndex)
Access Try to gain access to the data at a given index. The call needs to be embraced by calls of uin...
void ReadUnlock()
Definition: inos_syn.h:1045
int32 Decrement()
Decrement the reference counter and return the new value.
Definition: inos_syn.h:765
void Inquiry(void *aData, uint32 &aCountOfElements)
Gets the first element without removing it from the queue. Moreover, aCountOfElements returns the num...
uint32 mNumber
actual number of blocks in queue
Definition: inos_syn.h:662
virtual void Reset() override
Reset object state.
void SetFlag(uint32 auFlag)
Set queue flag(s)
Definition: inos_syn.h:615
void Remove(CINOSSync *aChild, bool aDelete=false)
int32 m_iCount
Reference count.
Definition: inos_syn.h:1013
volatile uint32 * GetLockAdr()
Return pointer to core locking structure.
Definition: inos_syn.h:130
virtual void Signal()
Put object into the signaled state.
Definition: inos_syn.h:106
CINOSQueue(const char *apName, uint32 auNumber, uint32 auSize)
Create a queue with the given name. See also Queue.
void NotifyAll()
Wake up all waiting tasks See http://en.cppreference.com/w/cpp/thread/condition_variable/notify_all f...
virtual ~CINOSRefCount()
Destroy reference counter.
virtual uint32 Wait(uint32 aTimeout=0xFFFFFFFF) override
void WriteLock()
Definition: inos_syn.h:1055
void * pBegin
pointer to begin of queue buffer
Definition: inos_syn.h:658
void EndAccess(uint32 msr)
EndAccess Needs to be called after Access.
void * pPut
pointer to actual put block
Definition: inos_syn.h:660
virtual void Reset()
Reset object state.
tTaskId m_idFstWaiting
id of first task waiting for the sync object
Definition: inos_syn.h:162
bool m_bManual
manual object yes/no
Definition: inos_syn.h:161
virtual void Reset() override
Reset object state.
Definition: cinosbit.h:53
bool InquiryAt(void *aData, uint32 auIndex)
Gets the element at auIndex (starting from 0..numberOfElementsInQueue) without removing it from the q...
Definition: inoskernel.h:238
void * m_pHandlerObj
Handler method to call when count reaches 0.
Definition: inos_syn.h:1015
uint32 mSize
size of block in queue
Definition: inos_syn.h:663
uint32 m_uCount
signaled count of object
Definition: inos_syn.h:160
void SetCount(int32 aiNewCount)
Set current count.
CINOSLockGuard(TLock &aLock)
Definition: inos_syn.h:922
Definition: inos_syn.h:960
uint32 Put(void *aData, uint32 aTimeout=0xFFFFFFFF, uint32 auFlags=0)
Put data to queue and wait for max. auTimeout usec if queue full.
uint32 mMaxNumber
maximum number of blocks in queue
Definition: inos_syn.h:664
Definition: inostype.h:257
virtual ~CINOSConditionVariable()
Destroy condition variable object.
uint32 mQueueFlags
queue flags
Definition: inos_syn.h:665
bool Empty()
Get queue state.
Definition: inos_syn.h:1100
Definition: inos_syn.h:680
uint32 GetMaxCount()
Get max. allowed count.
Definition: inos_syn.h:495
CINOSSyncNode * m_pNode
pointer to object node (if any)
Definition: inos_syn.h:165
CINOSSync(const char *aName=0, uint32 aInitialCount=0, bool aManual=false)
SINOSCoreLock m_Lock
core lock
Definition: inos_syn.h:164
Definition: inos_syn.h:512
CINOSBus * GetBus()
Definition: inos_syn.h:279
Definition: inostype.h:192
void * pGet
pointer to actual get block
Definition: inos_syn.h:661
uint32 BeginAccess()
BeginAccess Needs to be called before Access.
uint32 GetCount()
Get current count.
Definition: inos_syn.h:490
void wait(std::unique_lock< CINOSMutex > &lock, Predicate pred)
wait for being notified and 'pred' is true See http://en.cppreference.com/w/cpp/thread/condition_vari...
Definition: inos_syn.h:424
virtual ~CINOSSync()
Destroy sync object.
virtual ~CINOSSemaphore()
Destroy semaphore.
const uint32 GetSize() const
Return size of one queue entry.
Definition: inos_syn.h:587
virtual uint32 Wait(uint32 aTimeout=0xFFFFFFFF)
wait for signaled state for max. aTimeout usec
inosName32 m_sName
Reference counter name (for debugging purposes)
Definition: inos_syn.h:1011
void Wait(std::unique_lock< CINOSMutex > &lock)
wait for being notified (even spuriously) See http://en.cppreference.com/w/cpp/thread/condition_varia...
Definition: inos_syn.h:417
virtual const char * GetName() override
Get name of sync object.
Definition: inos_syn.h:779
CINOSLockGuard(TLock &aLock, uint32 auTimeout)
Definition: inos_syn.h:929
CINOSRefCount(const char *apParentName, const char *apBaseName, int32 aiInitialCount=0, void *apHandlerObj=NULL, void *apHandlerFunc=NULL)
Create a reference counter with the given name.
CINOSTimeEvent(uint32 aTime)
Definition: inos_syn.h:367
bool WaitFor(std::unique_lock< CINOSMutex > &lock, const std::chrono::duration< Rep, Period > &rel_time, Predicate pred)
wait for being notified waiting at most aTimeout. See http://en.cppreference.com/w/cpp/thread/conditi...
Definition: inos_syn.h:400
virtual bool MsgEvent(CINOSTaskExMsg *apMsg)
Definition: inos_syn.h:121
CINOSConditionVariable(const char *aName=nullptr)
Definition: inos_syn.h:825
virtual const char * GetName()
Get name of sync object.
Definition: inos_syn.h:94
const uint32 * GetAdrNumber() const
Return address of entries counter.
Definition: inos_syn.h:601
uint32 GetNumber()
Get number of queue entries.
const uint64 * GetAdrCount() const
Return address of overall counter.
Definition: inos_syn.h:608
void Flush()
Flush the queue.
virtual uint32 Wait(uint32 aTimeout=0xFFFFFFFF) override
wait for signaled state for max. aTimeout usec
CINOSSemaphore(const char *apName=0, uint32 auInitialCount=1, uint32 auMaxCount=0xffffffff)
Create a semaphore with the given name. See also Semaphore.
virtual void Signal() override
Put object into the signaled state.
Definition: inos_syn.h:455
uint32 Get(void *aData, uint32 aTimeout=0xFFFFFFFF)
Get data from queue and wait for max. auTimeout usec if queue empty.
Definition: inos_syn.h:1117
void And(CINOSSync *aChild)
void SignalAndUnlock(uint32 auMsr)
Put object into the signaled state and release the core lock.
Definition: inos_syn.h:196
virtual void SignalEx(CINOSTaskExMsg *apMsg, uint32 auRplId, uint32 auAppError)
Definition: inos_syn.h:115
const char * m_pName
name of sync object
Definition: inos_syn.h:159
void Or(CINOSSync *aChild)
void ReadLock()
Definition: inos_syn.h:1037
virtual const char * GetName() override
Get name of sync object.
Definition: inos_syn.h:722
void * pEnd
pointer to end of queue buffer
Definition: inos_syn.h:659
EStatus WaitFor(std::unique_lock< CINOSMutex > &lock, const std::chrono::duration< Rep, Period > &rel_time)
wait for being notified waiting at most aTimeout. See http://en.cppreference.com/w/cpp/thread/conditi...
Definition: inos_syn.h:389
void NotifyOne()
Wake up one waiting task See http://en.cppreference.com/w/cpp/thread/condition_variable/notify_one fo...
Definition: inos_1ms.h:90
virtual uint32 Wait(uint32 aTimeout=0xFFFFFFFF) override
wait for signaled state for max. aTimeout usec
void ClrFlag(uint32 auFlag)
Clear queue flag(s)
Definition: inos_syn.h:623
void Release()
Release seamphore.
Definition: inos_syn.h:708
uint32 Request(uint32 aTimeout=0xFFFFFFFF)
Wait for semaphore for a max. amount of time.
CINOSSemaphore * pSemaphore
semaphore to handle the number of queue entries
Definition: inos_syn.h:666
Definition: inos_syn.h:66
void RemoveAll(bool aDelete=false)
virtual ~CINOSQueue()
Destroy queue.
int32 GetCount()
Get current count.
int32 Increment()
Increment the reference counter and return the new value.
#define DECLARE_DYNAMIC(aClass)
Definition: cinospartitionmemory.h:328
Definition: cinostaskex.h:395
uint64 mCount
overall put count
Definition: inos_syn.h:667
virtual void Reset() override
Definition: inos_syn.h:234
tTaskId m_idLstWaiting
id of last task waiting for the sync object
Definition: inos_syn.h:163
virtual void Signal() override
Put object into the signaled state.
Definition: inos_syn.h:915
const uint32 GetMaxNumber() const
Return maximum number of entries.
Definition: inos_syn.h:594
Definition: cinostask.h:51