import queue
from dataclasses import dataclass
import typing
-import gc
from .fusedir import Directory, CollectionDirectory, TmpCollectionDirectory, MagicDirectory, TagsDirectory, ProjectDirectory, SharedDirectory, CollectionDirectoryBase
from .fusefile import File, StringFile, FuseArvadosFile
"""
def __init__(self, cap, min_entries=4):
+ # Standard dictionaries are ordered, but OrderedDict is still better here, see
+ # https://docs.python.org/3.11/library/collections.html#ordereddict-objects
+ # specifically we use move_to_end() which standard dicts don't have.
self._cache_entries = collections.OrderedDict()
self.cap = cap
self._total = 0
# "values"
values = collections.deque(self._cache_entries.values())
- while len(values) > 0:
+ while values:
if self._total < self.cap or len(self._cache_entries) < self.min_entries:
break
yield values.popleft()
qentry = None
with llfuse.lock:
- while len(locked_ops) > 0:
+ while locked_ops:
if locked_ops.popleft().inode_op(self, None):
self._inode_remove_queue.task_done()
self.cap_cache_event.clear()
self.events = None
- # We rely on the cyclic garbage collector to deallocate
- # Collection objects from the Python SDK. A lower GC
- # threshold encourages Python to be more aggressive in
- # reclaiming these and seems to slow down the growth in memory
- # usage over time.
- gc.set_threshold(200)
-
def init(self):
# Allow threads that are waiting for the driver to be finished
# initializing to continue
def clear(self):
"""Delete all entries"""
- if len(self._entries) == 0:
+ if not self._entries:
return
oldentries = self._entries
self._entries = {}
def objsize(self):
# This is a rough guess of the amount of overhead involved for
- # a collection; the calculation is each file averages 128
- # bytes in the manifest, but consume 1024 bytes when blown up
- # into Python data structures.
+ # a collection; the assumptions are that that each file
+ # averages 128 bytes in the manifest, but consume 1024 bytes
+ # of Python data structures, so 1024/128=8 means we estimate
+ # the RAM footprint at 8 times the size of bare manifest text.
return self._manifest_size * 8
def finalize(self):