def __init__(self,
label: str,
loader: Callable,
default=None,
lazy_load: bool = True,
on_access: Optional[Callable] = None,
on_pre_load: Optional[Callable] = None,
on_post_load: Optional[Callable] = None,
on_load_error: Optional[Callable] = None,
on_use_default: Optional[Callable] = None,
on_refresh: Optional[Callable] = None):
assert isinstance(
label, str) and label, "[label] must be a string and not empty"
self.__label = label
#
assert callable(loader), "[loader] must be a function"
self.__loader = loader
#
self.__default = default
#
if callable(on_access):
self.__on_access = on_access
#
if callable(on_pre_load):
self.__on_pre_load = on_pre_load
else:
self.__on_pre_load = default_on_pre_load
#
if callable(on_post_load):
self.__on_post_load = on_post_load
else:
self.__on_post_load = default_on_post_load
#
if callable(on_load_error):
self.__on_load_error = on_load_error
else:
self.__on_load_error = default_on_load_error
#
if callable(on_use_default):
self.__on_use_default = on_use_default
else:
self.__on_use_default = default_on_use_default
#
if callable(on_refresh):
self.__on_refresh = on_refresh
else:
self.__on_refresh = default_on_refresh
#
self.__load_lock = threading.RLock()
self.__rwhandler = rwlock.RWLockFairD()
#
if not lazy_load:
self.payload()
def test_read_vs_downgrade_fair(self) -> None:
"""
# Given: Instance of RWLockFairD.
# When: A reader lock is acquired OR A writer lock is downgraded.
# Then: The internal state should be the same.
"""
# ## Arrange
c_rwlock_1 = rwlock.RWLockFairD()
c_rwlock_2 = rwlock.RWLockFairD()
def assert_internal_state():
"""Assert internal."""
self.assertEqual(int(c_rwlock_1.v_read_count),
int(c_rwlock_2.v_read_count))
self.assertEqual(bool(c_rwlock_1.c_lock_read_count.locked()),
bool(c_rwlock_2.c_lock_read_count.locked()))
self.assertEqual(bool(c_rwlock_1.c_lock_read.locked()),
bool(c_rwlock_2.c_lock_read.locked()))
self.assertEqual(bool(c_rwlock_1.c_lock_write.locked()),
bool(c_rwlock_2.c_lock_write.locked()))
# ## Assume
assert_internal_state()
# ## Act
a_read_lock = c_rwlock_1.gen_rlock()
a_read_lock.acquire()
a_downgrade_lock: Union[rwlock.LockableD,
rwlock.Lockable] = c_rwlock_2.gen_wlock()
a_downgrade_lock.acquire()
assert isinstance(a_downgrade_lock, rwlock.LockableD)
a_downgrade_lock = a_downgrade_lock.downgrade()
# ## Assert
assert_internal_state()
a_read_lock.release()
a_downgrade_lock.release()
assert_internal_state()
def __init__(self,
label: str,
loader: Callable,
transformer: Callable = None,
default=None,
lazy_load: bool = True,
on_access: Optional[Callable] = None,
on_pre_load: Optional[Callable] = None,
on_post_load: Optional[Callable] = None,
on_load_error: Optional[Callable] = None,
on_use_default: Optional[Callable] = None,
on_refresh: Optional[Callable] = None):
assert isinstance(
label, str) and label, "[label] must be a string and not empty"
self.__label = label
#
assert callable(loader), "[loader] must be a function"
self.__loader = loader
#
assert transformer is None or callable(
transformer), "[transformer] must be a function"
self.__transformer = transformer
#
if default is not None:
self.__default = default
self.__default_initial = True
#
self.__setting = None
self.__setting_state = 0
self.__context = None
self.__context_state = 0
#
if callable(on_access):
self.__on_access = on_access
#
if callable(on_pre_load):
self.__on_pre_load = on_pre_load
else:
self.__on_pre_load = default_on_pre_load
#
if callable(on_post_load):
self.__on_post_load = on_post_load
else:
self.__on_post_load = default_on_post_load
#
if callable(on_load_error):
self.__on_load_error = on_load_error
else:
self.__on_load_error = default_on_load_error
#
if callable(on_use_default):
self.__on_use_default = on_use_default
else:
self.__on_use_default = default_on_use_default
#
if callable(on_refresh):
self.__on_refresh = on_refresh
else:
self.__on_refresh = default_on_refresh
#
self.__load_lock = threading.RLock()
self.__rwhandler = rwlock.RWLockFairD()
#
if not lazy_load:
self.payload()
#
self._observe()
help='Capacity of functions')
parser.add_argument('--rate',
default=-1,
type=float,
help='Capacity of functions')
args = parser.parse_args()
# Examle run:
# time python lru.py --requests 20 --workload torch-vgg --nr_fn 10 > output.log
workload = args.workload
requests = args.requests
nr_fn = args.nr_fn
capacity = args.capacity
rate = args.rate
rw = [rwlock.RWLockFairD() for _ in range(nr_fn)]
commands = []
threads = []
if rate == 0.75:
commands = [
0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4
] # 75%
elif rate == 0.5:
commands = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 7, 8, 9, 6, 5, 6, 7, 8, 9
] # 50%
elif rate == 0.25:
commands = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 3, 4, 1, 2, 0
def __init__(
self,
keys=None,
source="",
cache_time=300,
ignore_errors_period=0,
fileformat="jwks",
keytype="RSA",
keyusage=None,
kid="",
ignore_invalid_keys=True,
httpc=None,
httpc_params=None,
):
"""
Contains a set of keys that have a common origin.
The sources can be serveral:
- A dictionary provided at the initialization, see keys below.
- A list of dictionaries provided at initialization
- A file containing one of: JWKS, DER encoded key
- A URL pointing to a webpages from which an JWKS can be downloaded
:param keys: A dictionary or a list of dictionaries
with the keys ["kty", "key", "alg", "use", "kid"]
:param source: Where the key set can be fetch from
:param fileformat: For a local file either "jwks" or "der"
:param keytype: Iff local file and 'der' format what kind of key it is.
presently 'rsa' and 'ec' are supported.
:param keyusage: What the key loaded from file should be used for.
Only applicable for DER files
:param ignore_invalid_keys: Ignore invalid keys
:param httpc: A HTTP client function
:param httpc_params: Additional parameters to pass to the HTTP client
function
"""
self._keys = []
self.cache_time = cache_time
self.etag = ""
self.fileformat = fileformat.lower()
self.ignore_errors_period = ignore_errors_period
self.ignore_errors_until = None # UNIX timestamp of last error
self.ignore_invalid_keys = ignore_invalid_keys
self.imp_jwks = None
self.keytype = keytype
self.keyusage = keyusage
self.last_local = None # UNIX timestamp of last local update
self.last_remote = None # HTTP Date of last remote update
self.last_updated = 0
self.local = False
self.remote = False
self.source = None
self.time_out = 0
self._lock = rwlock.RWLockFairD()
self._lock_reader = self._lock.gen_rlock()
self._lock_writer = self._lock.gen_wlock()
if httpc:
self.httpc = httpc
else:
self.httpc = requests.request
self.httpc_params = httpc_params or {}
if keys:
self.source = None
if isinstance(keys, dict):
if "keys" in keys:
self._do_keys(keys["keys"])
else:
self._do_keys([keys])
else:
self._do_keys(keys)
else:
self._set_source(source, fileformat)
if self.local:
self._do_local(kid)
def __init__(self, dirname):
pathlib.Path('storage').mkdir(parents=True, exist_ok=True)
self.dirname = r"storage/" + dirname
pathlib.Path(self.dirname).mkdir(parents=True, exist_ok=True)
self.lock = rwlock.RWLockFairD()
def __init__(self, segments_path, log_path):
self.rwlock = rwlock.RWLockFairD()
self.commitlog, self.memtable = CommitLog.resume(log_path)
self.segments = Segments(segments_path)