Mark3 Realtime Kernel
readerwriter.cpp
Go to the documentation of this file.
1 /*===========================================================================
2  _____ _____ _____ _____
3  ___| _|__ __|_ |__ __|__ |__ __| __ |__ ______
4 | \ / | || \ || | || |/ / ||___ |
5 | \/ | || \ || \ || \ ||___ |
6 |__/\__/|__|_||__|\__\ __||__|\__\ __||__|\__\ __||______|
7  |_____| |_____| |_____| |_____|
8 
9 --[Mark3 Realtime Platform]--------------------------------------------------
10 
11 Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
12 See license.txt for more information
13 ===========================================================================*/
20 #include "mark3.h"
21 namespace Mark3
22 {
23 //---------------------------------------------------------------------------
24 void ReaderWriterLock::Init()
25 {
26  m_u8ReadCount = 0;
27  m_clGlobalMutex.Init();
28  m_clReaderMutex.Init();
29 }
30 
31 //---------------------------------------------------------------------------
32 void ReaderWriterLock::AcquireReader()
33 {
34  AcquireReader_i(0);
35 }
36 
37 //---------------------------------------------------------------------------
38 bool ReaderWriterLock::AcquireReader(uint32_t u32TimeoutMs_)
39 {
40  return AcquireReader_i(u32TimeoutMs_);
41 }
42 
43 //---------------------------------------------------------------------------
44 void ReaderWriterLock::ReleaseReader()
45 {
46  m_clReaderMutex.Claim();
47  m_u8ReadCount--;
48  if (0 == m_u8ReadCount) {
49  m_clGlobalMutex.Release();
50  }
51  m_clReaderMutex.Release();
52 }
53 
54 //---------------------------------------------------------------------------
55 void ReaderWriterLock::AcquireWriter()
56 {
57  AcquireWriter_i(0);
58 }
59 
60 //---------------------------------------------------------------------------
61 bool ReaderWriterLock::AcquireWriter(uint32_t u32TimeoutMs_)
62 {
63  return AcquireWriter_i(u32TimeoutMs_);
64 }
65 
66 //---------------------------------------------------------------------------
67 void ReaderWriterLock::ReleaseWriter()
68 {
69  m_clGlobalMutex.Release();
70 }
71 
72 //---------------------------------------------------------------------------
73 bool ReaderWriterLock::AcquireReader_i(uint32_t u32TimeoutMs_)
74 {
75  auto rc = true;
76  if (!m_clReaderMutex.Claim(u32TimeoutMs_)) {
77  return false;
78  }
79 
80  m_u8ReadCount++;
81  if (1 == m_u8ReadCount) {
82  rc = m_clGlobalMutex.Claim(u32TimeoutMs_);
83  }
84 
85  m_clReaderMutex.Release();
86  return rc;
87 }
88 
89 //---------------------------------------------------------------------------
90 bool ReaderWriterLock::AcquireWriter_i(uint32_t u32TimeoutMs_)
91 {
92  return m_clGlobalMutex.Claim(u32TimeoutMs_);
93 }
94 } // namespace Mark3
Mark3::ReaderWriterLock::m_u8ReadCount
uint8_t m_u8ReadCount
Number of concurrent readers.
Definition: readerwriter.h:118
Mark3::ReaderWriterLock::m_clGlobalMutex
Mutex m_clGlobalMutex
Mutex used to lock the object against concurrent read + write.
Definition: readerwriter.h:116
Mark3::Mutex::Release
void Release()
Release Release the mutex. When the mutex is released, another object can enter the mutex-protected r...
Definition: mutex.cpp:197
Mark3::Mutex::Claim
void Claim()
Claim Claim the mutex. When the mutex is claimed, no other thread can claim a region protected by the...
Definition: mutex.cpp:185
Mark3::ReaderWriterLock::ReleaseWriter
void ReleaseWriter()
ReleaseWriter Release the currently held writer, allowing other readers/writers to access the object...
Definition: readerwriter.cpp:67
Mark3
Definition: atomic.cpp:23
mark3.h
Single include file given to users of the Mark3 Kernel API.
Mark3::ReaderWriterLock::AcquireReader_i
bool AcquireReader_i(uint32_t u32TimeoutMs_)
AcquireReader_i Internal helper function for AcquireReaer.
Definition: readerwriter.cpp:73
Mark3::ReaderWriterLock::Init
void Init()
Init Initialize the reader-writer lock before use. Must be called before attempting any other operati...
Definition: readerwriter.cpp:24
Mark3::ReaderWriterLock::AcquireReader
void AcquireReader()
AcquireReader Acquire the object's reader lock. Multiple concurrent readers are allowed. If the writer lock is currently held, the calling thread will wait until the writer lock is relinquished.
Definition: readerwriter.cpp:32
Mark3::ReaderWriterLock::AcquireWriter
void AcquireWriter()
AcquireWriter Acquire the writer lock. Only a single writer is allowed to access the object at a time...
Definition: readerwriter.cpp:55
Mark3::ReaderWriterLock::AcquireWriter_i
bool AcquireWriter_i(uint32_t u32TimeoutMs_)
AcquireWriter_i Internal helper function for AcquireWriter.
Definition: readerwriter.cpp:90
Mark3::Mutex::Init
void Init(bool bRecursive_=true)
Init Initialize a mutex object for use - must call this function before using the object...
Definition: mutex.cpp:93
Mark3::ReaderWriterLock::ReleaseReader
void ReleaseReader()
ReleaseReader Release a previously-held reader lock.
Definition: readerwriter.cpp:44
Mark3::ReaderWriterLock::m_clReaderMutex
Mutex m_clReaderMutex
Mutex used to lock object for readers.
Definition: readerwriter.h:117