reader_writer_lock.h

Go to the documentation of this file.

/*
    Copyright (c) 2005-2019 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.




*/

#ifndef __TBB_reader_writer_lock_H
#define __TBB_reader_writer_lock_H

#include "tbb_thread.h"
#include "tbb_allocator.h"
#include "atomic.h"

namespace tbb {
namespace interface5 {

    class reader_writer_lock : tbb::internal::no_copy {
 public:
    friend class scoped_lock;
    friend class scoped_lock_read;

    enum status_t { waiting_nonblocking, waiting, active, invalid };

    reader_writer_lock() {
        internal_construct();
    }

    ~reader_writer_lock() {
        internal_destroy();
    }


    class scoped_lock : tbb::internal::no_copy {
    public:
        friend class reader_writer_lock;

        scoped_lock(reader_writer_lock& lock) {
            internal_construct(lock);
        }

        ~scoped_lock() {
            internal_destroy();
        }

        void* operator new(size_t s) {
            return tbb::internal::allocate_via_handler_v3(s);
        }
        void operator delete(void* p) {
            tbb::internal::deallocate_via_handler_v3(p);
        }

    private:
        reader_writer_lock *mutex;
        scoped_lock* next;
        atomic<status_t> status;

        scoped_lock();

        void __TBB_EXPORTED_METHOD internal_construct(reader_writer_lock&);
        void __TBB_EXPORTED_METHOD internal_destroy();
   };

    class scoped_lock_read : tbb::internal::no_copy {
    public:
        friend class reader_writer_lock;

        scoped_lock_read(reader_writer_lock& lock) {
            internal_construct(lock);
        }

        ~scoped_lock_read() {
            internal_destroy();
        }

        void* operator new(size_t s) {
            return tbb::internal::allocate_via_handler_v3(s);
        }
        void operator delete(void* p) {
            tbb::internal::deallocate_via_handler_v3(p);
        }

    private:
        reader_writer_lock *mutex;
        scoped_lock_read *next;
        atomic<status_t> status;

        scoped_lock_read();

        void __TBB_EXPORTED_METHOD internal_construct(reader_writer_lock&);
        void __TBB_EXPORTED_METHOD internal_destroy();
    };


    void __TBB_EXPORTED_METHOD lock();


    bool __TBB_EXPORTED_METHOD try_lock();


    void __TBB_EXPORTED_METHOD lock_read();


    bool __TBB_EXPORTED_METHOD try_lock_read();

    void __TBB_EXPORTED_METHOD unlock();

 private:
    void __TBB_EXPORTED_METHOD internal_construct();
    void __TBB_EXPORTED_METHOD internal_destroy();


    bool start_write(scoped_lock *);
    void set_next_writer(scoped_lock *w);
    void end_write(scoped_lock *);
    bool is_current_writer();


    void start_read(scoped_lock_read *);
    void unblock_readers();
    void end_read();

    atomic<scoped_lock_read*> reader_head;
    atomic<scoped_lock*> writer_head;
    atomic<scoped_lock*> writer_tail;
    tbb_thread::id my_current_writer;
    atomic<uintptr_t> rdr_count_and_flags; // used with __TBB_AtomicOR, which assumes uintptr_t
};

} // namespace interface5

using interface5::reader_writer_lock;

} // namespace tbb

#endif /* __TBB_reader_writer_lock_H */