Delete obsolete noisicaa.rwlock module.

Ben Niemann 5 years ago
parent 250271d669
commit df3f2588fb

@ -554,7 +554,6 @@ Is there some cross-compiler/-platform header to provide this functionality?
- auto convert as needed
- absl::Mutex for
- absl::Substitude for sprintf
- absl::string_view for method args
- absl::GetCurrentTimeNanos() for PerfStats

@ -25,7 +25,6 @@ add_python_package(

@ -1,177 +0,0 @@
# @custom_license
# Cloned from proposed RWLock in stdlib's threading module.
# Classes from threading seem to often reference protected members from other
# classes.
# pylint: disable=W0212
import threading
# The internal lock object managing the RWLock state.
class _RWLockCore(object):
def __init__(self):
self.cond = threading.Condition()
self.state = 0 # positive is shared count, negative exclusive count
self.waiting = 0
self.owning = [] # threads will be few, so a list is not inefficient
# Acquire the lock in read mode.
def acquire_read(self, timeout=None):
with self.cond:
return self.cond.wait_for(self._acquire_read, timeout)
def _acquire_read(self):
if self.state < 0:
# lock is in write mode. See if it is ours and we can recurse
return self._acquire_write()
# Implement "exclusive bias" giving exclusive lock priority.
me = threading.get_ident()
if not self.waiting:
ok = True # no exclusive acquires waiting.
# Recursion must have the highest priority, otherwise we deadlock
ok = me in self.owning
if ok:
self.state += 1
return ok
# Acquire the lock in write mode. A 'waiting' count is maintainded,
# ensurring that 'readers' will yield to writers.
def acquire_write(self, timeout=None):
with self.cond:
self.waiting += 1
return self.cond.wait_for(self._acquire_write, timeout)
self.waiting -= 1
def _acquire_write(self):
#we can only take the write lock if no one is there, or we already hold the lock
me = threading.get_ident()
if self.state == 0 or (self.state < 0 and me in self.owning):
self.state -= 1
return True
if self.state > 0 and me in self.owning:
raise RuntimeError("cannot upgrade RWLock from read to write")
return False
# Release the lock
def release(self):
with self.cond:
me = threading.get_ident()
except ValueError:
raise RuntimeError("cannot release an un-acquired lock")
if self.state > 0:
self.state -= 1
self.state += 1
if self.state == 0:
# Interface for condition variable. Must hold an exclusive lock since the
# condition variable's state may be protected by the lock
def _is_owned(self):
return self.state < 0 and threading.get_ident() in self.owning
def _release_save(self):
# In a exlusively locked state, get the recursion level and free the lock
with self.cond:
if threading.get_ident() not in self.owning:
raise RuntimeError("cannot release an un-acquired lock")
r = self.owning
self.owning = []
self.state = 0
return r
def _acquire_restore(self, x):
# Reclaim the exclusive lock at the old recursion level
with self.cond:
self.owning = x
self.state = -len(x)
# Lock objects to access the _RWLockCore in reader or writer mode
class _ReaderLock:
def __init__(self, lock):
self.lock = lock
def _timeout(blocking, timeout):
# A few sanity checks to satisfy the unittests.
if timeout < 0 and timeout != -1:
raise ValueError("invalid timeout")
if timeout > 10000:
raise OverflowError
if blocking:
return timeout if timeout >= 0 else None
if timeout > 0:
raise ValueError("can't specify a timeout when non-blocking")
return 0
def acquire(self, blocking=True, timeout=-1):
return self.lock.acquire_read(self._timeout(blocking, timeout))
def release(self):
def __enter__(self):
def __exit__(self, exc, val, tb):
def _is_owned(self):
raise TypeError("a reader lock cannot be used with a Condition")
class _WriterLock(_ReaderLock):
def acquire(self, blocking=True, timeout=-1):
return self.lock.acquire_write(self._timeout(blocking, timeout))
def _is_owned(self):
return self.lock._is_owned()
def _release_save(self):
return self.lock._release_save()
def _acquire_restore(self, arg):
return self.lock._acquire_restore(arg)
class RWLock():
# Doc shamelessly ripped off from Java
A RWLock maintains a pair of associated locks, one for read-only operations
and one for writing. The read lock may be held simultaneously by multiple
reader threads, so long as there are no writers. The write lock is exclusive.
core = _RWLockCore
def __init__(self):
core = self.core()
self._reader_lock = _ReaderLock(core)
self._writer_lock = _WriterLock(core)
def reader_lock(self):
The lock used for read, or shared, access
return self._reader_lock
def writer_lock(self):
The lock used for write, or exclusive, access
return self._writer_lock