/usr/include/tango/readers_writers_lock.h is in libtango-dev 9.2.5a+dfsg1-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | // -*- Mode: C++; -*-
//
// ReadersWritersLock.h Author : Tristan Richardson (tjr)
// Jens Meyer
// Emmanuel Taurel
//
// Copyright (C) : 1997-1999 AT&T Laboratories Cambridge
// 2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015
// European Synchrotron Radiation Facility
// BP 220, Grenoble 38043
// FRANCE
//
// This file is part of Tango.
//
// Tango is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Tango is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Tango. If not, see <http://www.gnu.org/licenses/>.
#ifndef _ReadersWritersLock_h_
#define _ReadersWritersLock_h_
#include <omnithread.h>
class ReadersWritersLock {
public:
omni_mutex mut;
omni_condition cond;
int n; // 0 means no-one active, > 0 means n readers, < 0 means writer
// (-n times).
int writerId;
ReadersWritersLock(void) : cond(&mut), n(0), writerId(0), auto_self(NULL) {}
void readerIn(void)
{
mut.lock();
// In the case of usage with another threading library, omni_thread::self() might
// return a NULL pointer!
int threadId = 0;
omni_thread *th = omni_thread::self();
if ( th != NULL )
{
threadId = th->id();
}
if ((n < 0) && (writerId == threadId))
{
// this thread already has lock as writer, simply decrement n
n--;
mut.unlock();
return;
}
while (n < 0)
cond.wait();
n++;
mut.unlock();
}
void readerOut(void)
{
mut.lock();
if (n < 0)
{
// this thread already had lock as writer, simply increment n
n++;
mut.unlock();
return;
}
n--;
if (n == 0)
cond.signal();
mut.unlock();
}
void writerIn(void)
{
mut.lock();
// In the case of usage with another threading library, omni_thread::self() might
// return a NULL pointer!
int threadId = 0;
omni_thread *th = omni_thread::self();
if ( th != NULL )
{
threadId = th->id();
}
if ((n < 0) && (writerId == threadId))
{
// this thread already has lock as writer, simply decrement n
n--;
mut.unlock();
return;
}
while (n != 0)
cond.wait();
n--;
// Now the writer lock was taken.
// Make sure we get a correct thread ID
// With the class ensure_self it should return always a thread ID.
// Create the ensure_self object only for the thread which takes the writer lock!
if (th == NULL)
auto_self = new omni_thread::ensure_self();
writerId = omni_thread::self()->id();
mut.unlock();
}
void writerOut(void)
{
mut.lock();
n++;
if (n == 0)
{
// delete the dummy thread when it was created.
if (auto_self != NULL)
{
delete auto_self;
auto_self = NULL;
}
cond.broadcast(); // might as well wake up all readers
}
mut.unlock();
}
private:
// in the case of usage with another threading library, omni_thread::self() might
// return a NULL pointer!
// To avoid this problem we use the class ensure_self to get a dummy thread ID!
//
// The class ensure_self should be created on the stack. If created in
// a thread without an associated omni_thread, it creates a dummy
// thread which is released when the ensure_self object is deleted.
omni_thread::ensure_self *auto_self;
};
//
// As an alternative to:
// {
// lock.readerIn();
// .....
// lock.readerOut();
// }
//
// you can use a single instance of the ReaderLock class:
//
// {
// ReaderLock r(lock);
// ....
// }
//
// This has the advantage that lock.readerOut() will be called automatically
// when an exception is thrown.
//
class ReaderLock {
ReadersWritersLock& rwl;
public:
ReaderLock(ReadersWritersLock& l) : rwl(l) { rwl.readerIn(); }
~ReaderLock(void) { rwl.readerOut(); }
};
//
// Similarly the WriterLock class can be used instead of lock.writerIn() and
// lock.writerOut().
//
class WriterLock {
ReadersWritersLock& rwl;
public:
WriterLock(ReadersWritersLock& l) : rwl(l) { rwl.writerIn(); }
~WriterLock(void) { rwl.writerOut(); }
};
#endif
|