Fix code style and consistency of RWLock and Semaphore

core/os/rw_lock.h

@@ -34,6 +34,7 @@
 #include "core/error_list.h"
 
 #if !defined(NO_THREADS)
+#include "core/typedefs.h"
 
 #include <shared_mutex>
 
@@ -41,33 +42,33 @@ class RWLock {
 	mutable std::shared_timed_mutex mutex;
 
 public:
-	// Lock the rwlock, block if locked by someone else
-	void read_lock() const {
+	// Lock the RWLock, block if locked by someone else.
+	_ALWAYS_INLINE_ void read_lock() const {
 		mutex.lock_shared();
 	}
 
-	// Unlock the rwlock, let other threads continue
-	void read_unlock() const {
+	// Unlock the RWLock, let other threads continue.
+	_ALWAYS_INLINE_ void read_unlock() const {
 		mutex.unlock_shared();
 	}
 
-	// Attempt to lock the rwlock, OK on success, ERR_BUSY means it can't lock.
-	Error read_try_lock() const {
+	// Attempt to lock the RWLock for reading. True on success, false means it can't lock.
+	_ALWAYS_INLINE_ Error read_try_lock() const {
 		return mutex.try_lock_shared() ? OK : ERR_BUSY;
 	}
 
-	// Lock the rwlock, block if locked by someone else
-	void write_lock() {
+	// Lock the RWLock, block if locked by someone else.
+	_ALWAYS_INLINE_ void write_lock() {
 		mutex.lock();
 	}
 
-	// Unlock the rwlock, let other thwrites continue
-	void write_unlock() {
+	// Unlock the RWLock, let other threads continue.
+	_ALWAYS_INLINE_ void write_unlock() {
 		mutex.unlock();
 	}
 
-	// Attempt to lock the rwlock, OK on success, ERR_BUSY means it can't lock.
-	Error write_try_lock() {
+	// Attempt to lock the RWLock for writing. True on success, false means it can't lock.
+	_ALWAYS_INLINE_ Error write_try_lock() {
 		return mutex.try_lock() ? OK : ERR_BUSY;
 	}
 };
@@ -91,11 +92,11 @@ class RWLockRead {
 	const RWLock &lock;
 
 public:
-	RWLockRead(const RWLock &p_lock) :
+	_ALWAYS_INLINE_ RWLockRead(const RWLock &p_lock) :
 			lock(p_lock) {
 		lock.read_lock();
 	}
-	~RWLockRead() {
+	_ALWAYS_INLINE_ ~RWLockRead() {
 		lock.read_unlock();
 	}
 };
@@ -104,11 +105,11 @@ class RWLockWrite {
 	RWLock &lock;
 
 public:
-	RWLockWrite(RWLock &p_lock) :
+	_ALWAYS_INLINE_ RWLockWrite(RWLock &p_lock) :
 			lock(p_lock) {
 		lock.write_lock();
 	}
-	~RWLockWrite() {
+	_ALWAYS_INLINE_ ~RWLockWrite() {
 		lock.write_unlock();
 	}
 };

core/os/semaphore.h

@@ -41,37 +41,38 @@
 
 class Semaphore {
 private:
-	mutable std::mutex mutex_;
-	mutable std::condition_variable condition_;
-	mutable unsigned long count_ = 0; // Initialized as locked.
+	mutable std::mutex mutex;
+	mutable std::condition_variable condition;
+	mutable uint32_t count = 0; // Initialized as locked.
 
 public:
 	_ALWAYS_INLINE_ void post() const {
-		std::lock_guard<decltype(mutex_)> lock(mutex_);
-		++count_;
-		condition_.notify_one();
+		std::lock_guard<std::mutex> lock(mutex);
+		count++;
+		condition.notify_one();
 	}
 
 	_ALWAYS_INLINE_ void wait() const {
-		std::unique_lock<decltype(mutex_)> lock(mutex_);
-		while (!count_) { // Handle spurious wake-ups.
-			condition_.wait(lock);
+		std::unique_lock<std::mutex> lock(mutex);
+		while (!count) { // Handle spurious wake-ups.
+			condition.wait(lock);
 		}
-		--count_;
+		count--;
 	}
 
 	_ALWAYS_INLINE_ bool try_wait() const {
-		std::lock_guard<decltype(mutex_)> lock(mutex_);
-		if (count_) {
-			--count_;
+		std::lock_guard<std::mutex> lock(mutex);
+		if (count) {
+			count--;
 			return true;
-		}
+		} else {
 			return false;
 		}
+	}
 
 	_ALWAYS_INLINE_ int get() const {
-		std::lock_guard<decltype(mutex_)> lock(mutex_);
-		return count_;
+		std::lock_guard<std::mutex> lock(mutex);
+		return count;
 	}
 };