Sead/Locks

Lock classes that are contained in the sead namespace are classified as classes that pertain to locking regions of memory or data to prevent accidental mishandling.

CriticalSection

CriticalSection is a class that contains a region of code that is protected to ensure that it is executed on one thread at a time. To perform this, the class stores a mutex semaphore. It inherits from the IDisposer class.

namespace sead
{
    class CriticalSection : sead::IDisposer
    {
    public:
        // default constructor. Initializes the stored mutex type.
        CriticalSection();
        // constructor that initializes the section disposer with a heap and initializes the stored mutex type.
        CriticalSection(sead::Heap *);
        // constructor that initializes the section disposer with a heap and a null option, and initializes the mutex type.
        CriticalSection(sead::Heap *, sead::IDisposer::HeapNullOption);
        // destructor
        ~CriticalSection();

        // locks the section
        void lock();
        // attempts to lock the section, True is successful, False if failure
        bool tryLock();
        // unlock the section
        void unlock();

        nn::os::MutexType* mMutexType; // _20
    };
};

ReadWriteLock

The ReadWriteLock class serves as a Read/Write lock, as the name implies. The purpose of this class is to allow concurrent access for read-only processes, and requiring write operations exclusive accesses. This class is open for multiple threads to read / write data at once. It uses two semaphores for each type of lock, read and write.

namespace sead
{
    class ReadWriteLock
    {
    public:

        class SemaphoreLock : public sead::Semaphore
        {
        public:
            SemaphoreLock();

            void lock();
            void unlock();

            u32 _48;
        };

        ReadWriteLock();
        ~ReadWriteLock();

        void readLock();
        void readUnlock();
        void writeLock();
        void writeUnlock();

        u32 _0;
        u32 _4;
        sead::Semaphore mReadSemaphore; // _8
        u32 _50;
        u32 _54;
        sead::Semaphore mWriteSemaphore; // _58
        u32 _A0;
        /// Thread that is currently holding the write lock.
        sead::Thread* mWriterThread; // _A8
        u32 _B0;
    };
};

SpinLock

The SpinLock class is responsible for making threads that wish to acquire a lock be stuck in a loop until the lock is available, as it checks every iteration as it waits.

namespace sead
{
	class SpinLock
	{
	public:
        // default constructor, sets all members to 0
		SpinLock();
        // destructor
		~SpinLock();
		
        // locks the iteration
		void lock();
        // attempts to lock the iteration. True if successful, False if failure
		bool tryLock();
        // unlock the iteration
		void unlock();
		
		u64 mDest; // _0
		u32 mNumber; // _8
	};
};