/* MultiLocker.h */
/*
        Copyright 1999, Be Incorporated.   All Rights Reserved.
        This file may be used under the terms of the Be Sample Code License.
*/

/* multiple-reader single-writer locking class */

#ifndef MULTI_LOCKER_H
#define MULTI_LOCKER_H

//#define TIMING 1

#include <OS.h>

const int32 LARGE_NUMBER = 100000;

class MultiLocker {
        public:
                                                                MultiLocker(const char* semaphoreBaseName);
                virtual                                 ~MultiLocker();
                
                status_t                                InitCheck();
                
                //locking for reading or writing
                bool                                    ReadLock();
                bool                                    WriteLock();

                //unlocking after reading or writing
                bool                                    ReadUnlock();
                bool                                    WriteUnlock();

                //does the current thread hold a write lock ?
                bool                                    IsWriteLocked(uint32 *stack_base = NULL, thread_id *thread = NULL);
                //in DEBUG mode returns whether the lock is held
                //in non-debug mode returns true
                bool                                    IsReadLocked();

        private:
                //functions for managing the DEBUG reader array
                void                                    register_thread();
                void                                    unregister_thread();
                
                status_t                                fInit;
                //readers adjust count and block on fReadSem when a writer
                //hold the lock
                int32                                   fReadCount;
                sem_id                                  fReadSem;
                //writers adjust the count and block on fWriteSem
                //when readers hold the lock
                int32                                   fWriteCount;
                sem_id                                  fWriteSem;
                //writers must acquire fWriterLock when acquiring a write lock
                int32                                   fLockCount;
                sem_id                                  fWriterLock;
                int32                                   fWriterNest;
        
                thread_id                               fWriterThread;
                uint32                                  fWriterStackBase;
                                
                int32 *                                 fDebugArray;
                int32                                   fMaxThreads;

#if TIMING
                uint32                                  rl_count;
                bigtime_t                               rl_time;
                uint32                                  ru_count;
                bigtime_t                               ru_time;
                uint32                                  wl_count;
                bigtime_t                               wl_time;
                uint32                                  wu_count;
                bigtime_t                               wu_time;
                uint32                                  islock_count;
                bigtime_t                               islock_time;
                uint32                                  reg_count;
                bigtime_t                               reg_time;
                uint32                                  unreg_count;
                bigtime_t                               unreg_time;
#endif
};

class AutoWriteLocker {
 public:
                                                                AutoWriteLocker(MultiLocker* lock)
                                                                        : fLock(lock)
                                                                {
                                                                        fLock->WriteLock();
                                                                }
                                                                ~AutoWriteLocker()
                                                                {
                                                                        fLock->WriteUnlock();
                                                                }
 private:
                MultiLocker*                    fLock;
};

class AutoReadLocker {
 public:
                                                                AutoReadLocker(MultiLocker* lock)
                                                                        : fLock(lock)
                                                                {
                                                                        fLock->ReadLock();
                                                                }
                                                                ~AutoReadLocker()
                                                                {
                                                                        fLock->ReadUnlock();
                                                                }
 private:
                MultiLocker*                    fLock;
};



#endif