def test_write_once_persistent_dict_storage_and_lookup(in_mem_cache_size): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict("pytools-test", container_dir=tmpdir, in_mem_cache_size=in_mem_cache_size) # check lookup pdict[0] = 1 assert pdict[0] == 1 # do two lookups to test the cache assert pdict[0] == 1 # check updating with pytest.raises(ReadOnlyEntryError): pdict[0] = 2 # check not found with pytest.raises(NoSuchEntryError): pdict.fetch(1) # check store_if_not_present pdict.store_if_not_present(0, 2) assert pdict[0] == 1 pdict.store_if_not_present(1, 1) assert pdict[1] == 1 finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_synchronization(): try: tmpdir = tempfile.mkdtemp() pdict1 = WriteOncePersistentDict("pytools-test", container_dir=tmpdir) pdict2 = WriteOncePersistentDict("pytools-test", container_dir=tmpdir) # check lookup pdict1[1] = 0 assert pdict2[1] == 0 # check updating with pytest.raises(ReadOnlyEntryError): pdict2[1] = 1 finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_storage_and_lookup(in_mem_cache_size): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict( "pytools-test", container_dir=tmpdir, in_mem_cache_size=in_mem_cache_size) # check lookup pdict[0] = 1 assert pdict[0] == 1 # do two lookups to test the cache assert pdict[0] == 1 # check updating with pytest.raises(ReadOnlyEntryError): pdict[0] = 2 # check not found with pytest.raises(NoSuchEntryError): pdict.fetch(1) # check store_if_not_present pdict.store_if_not_present(0, 2) assert pdict[0] == 1 pdict.store_if_not_present(1, 1) assert pdict[1] == 1 finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_clear(): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict("pytools-test", container_dir=tmpdir) pdict[0] = 1 pdict.fetch(0) pdict.clear() with pytest.raises(NoSuchEntryError): pdict.fetch(0) finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_clear(): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict("pytools-test", container_dir=tmpdir) pdict[0] = 1 pdict.fetch(0) pdict.clear() with pytest.raises(NoSuchEntryError): pdict.fetch(0) finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_cache_collisions(): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict("pytools-test", container_dir=tmpdir) key1 = PDictTestingKeyOrValue(1, hash_key=0) key2 = PDictTestingKeyOrValue(2, hash_key=0) pdict[key1] = 1 # check lookup with pytest.warns(CollisionWarning): with pytest.raises(NoSuchEntryError): pdict.fetch(key2) # check update with pytest.raises(ReadOnlyEntryError): pdict[key2] = 1 # check store_if_not_present pdict.store_if_not_present(key2, 2) assert pdict[key1] == 1 finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_cache_collisions(): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict("pytools-test", container_dir=tmpdir) key1 = PDictTestingKeyOrValue(1, hash_key=0) key2 = PDictTestingKeyOrValue(2, hash_key=0) pdict[key1] = 1 # check lookup with pytest.warns(CollisionWarning): with pytest.raises(NoSuchEntryError): pdict.fetch(key2) # check update with pytest.raises(ReadOnlyEntryError): pdict[key2] = 1 # check store_if_not_present pdict.store_if_not_present(key2, 2) assert pdict[key1] == 1 finally: shutil.rmtree(tmpdir)
""" import os from sumpy.p2p import P2P, P2PFromCSR from sumpy.p2e import P2EFromSingleBox, P2EFromCSR from sumpy.e2p import E2PFromSingleBox, E2PFromCSR from sumpy.e2e import E2EFromCSR, E2EFromChildren, E2EFromParent from sumpy.version import VERSION_TEXT from pytools.persistent_dict import WriteOncePersistentDict __all__ = [ "P2P", "P2PFromCSR", "P2EFromSingleBox", "P2EFromCSR", "E2PFromSingleBox", "E2PFromCSR", "E2EFromCSR", "E2EFromChildren", "E2EFromParent" ] code_cache = WriteOncePersistentDict("sumpy-code-cache-v6-" + VERSION_TEXT) # {{{ cache control CACHING_ENABLED = True CACHING_ENABLED = ("SUMPY_NO_CACHE" not in os.environ and "CG_NO_CACHE" not in os.environ) def set_caching_enabled(flag): """Set whether :mod:`loopy` is allowed to use disk caching for its various code generation stages. """ global CACHING_ENABLED CACHING_ENABLED = flag
# {{{ generate set_args gen("") gen("def set_args(%s):" % (", ".join(["self"] + arg_names))) with Indentation(gen): add_local_imports(gen) gen.extend(err_handler) # }}} return gen.get_picklable_module(), enqueue_name invoker_cache = WriteOncePersistentDict("pyopencl-invoker-cache-v1", key_builder=_NumpyTypesKeyBuilder()) def generate_enqueue_and_set_args(function_name, num_passed_args, num_cl_args, scalar_arg_dtypes, work_around_arg_count_bug, warn_about_arg_count_bug): cache_key = (function_name, num_passed_args, num_cl_args, scalar_arg_dtypes, work_around_arg_count_bug, warn_about_arg_count_bug) from_cache = False try: result = invoker_cache[cache_key] from_cache = True
result = self.buf_var if access_subscript: result = result.index(tuple(access_subscript)) # Can't possibly be nested, but recurse anyway to # make sure substitution rules referenced below here # do not get thrown away. self.rec(result, expn_state.copy(arg_context={})) return result # }}} buffer_array_cache = WriteOncePersistentDict( "loopy-buffer-array-cache-"+DATA_MODEL_VERSION, key_builder=LoopyKeyBuilder()) # Adding an argument? also add something to the cache_key below. def buffer_array(kernel, var_name, buffer_inames, init_expression=None, store_expression=None, within=None, default_tag="l.auto", temporary_scope=None, temporary_is_local=None, fetch_bounding_box=False): """Replace accesses to *var_name* with ones to a temporary, which is created and acts as a buffer. To perform this transformation, the access footprint to *var_name* is determined and a temporary of a suitable :class:`loopy.AddressSpace` and shape is created. By default, the value of the buffered cells in *var_name* are read prior to any (read/write) use, and the modified values are written out after use has
from loopy.codegen.result import merge_codegen_results return merge_codegen_results(self, result) @property def ast_builder(self): if self.is_generating_device_code: return self.kernel.target.get_device_ast_builder() else: return self.kernel.target.get_host_ast_builder() # }}} code_gen_cache = WriteOncePersistentDict("loopy-code-gen-cache-v3-" + DATA_MODEL_VERSION, key_builder=LoopyKeyBuilder()) class PreambleInfo(ImmutableRecord): """ .. attribute:: kernel .. attribute:: seen_dtypes .. attribute:: seen_functions .. attribute:: seen_atomic_dtypes .. attribute:: codegen_state """ # {{{ main code generation entrypoint
# }}} # }}} class _KernelInfo(ImmutableRecord): pass class _Kernels: pass typed_and_scheduled_cache = WriteOncePersistentDict( "loopy-typed-and-scheduled-cache-v1-"+DATA_MODEL_VERSION, key_builder=LoopyKeyBuilder()) invoker_cache = WriteOncePersistentDict( "loopy-invoker-cache-v10-"+DATA_MODEL_VERSION, key_builder=LoopyKeyBuilder()) # {{{ kernel executor class KernelExecutorBase: """An object connecting a kernel to a :class:`pyopencl.Context` for execution. .. automethod:: __init__
def test_write_once_persistent_dict_lru_policy(): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict("pytools-test", container_dir=tmpdir, in_mem_cache_size=3) pdict[1] = PDictTestingKeyOrValue(1) pdict[2] = PDictTestingKeyOrValue(2) pdict[3] = PDictTestingKeyOrValue(3) pdict[4] = PDictTestingKeyOrValue(4) val1 = pdict.fetch(1) assert pdict.fetch(1) is val1 pdict.fetch(2) assert pdict.fetch(1) is val1 pdict.fetch(2) pdict.fetch(3) assert pdict.fetch(1) is val1 pdict.fetch(2) pdict.fetch(3) pdict.fetch(2) assert pdict.fetch(1) is val1 pdict.fetch(2) pdict.fetch(3) pdict.fetch(4) assert pdict.fetch(1) is not val1 finally: shutil.rmtree(tmpdir)
def test_write_once_persistent_dict_lru_policy(): try: tmpdir = tempfile.mkdtemp() pdict = WriteOncePersistentDict( "pytools-test", container_dir=tmpdir, in_mem_cache_size=3) pdict[1] = PDictTestingKeyOrValue(1) pdict[2] = PDictTestingKeyOrValue(2) pdict[3] = PDictTestingKeyOrValue(3) pdict[4] = PDictTestingKeyOrValue(4) val1 = pdict.fetch(1) assert pdict.fetch(1) is val1 pdict.fetch(2) assert pdict.fetch(1) is val1 pdict.fetch(2) pdict.fetch(3) assert pdict.fetch(1) is val1 pdict.fetch(2) pdict.fetch(3) pdict.fetch(2) assert pdict.fetch(1) is val1 pdict.fetch(2) pdict.fetch(3) pdict.fetch(4) assert pdict.fetch(1) is not val1 finally: shutil.rmtree(tmpdir)
from volumential.singular_integral_2d import box_quad from volumential.version import VERSION_TEXT from volumential.table_manager import NearFieldInteractionTableManager # noqa: F401 from volumential.nearfield_potential_table import ( # noqa: F401 NearFieldInteractionTable, ) volumential_version = VERSION_TEXT __all__ = ["volumential_version", "box_quad", "nearfield_potential_table"] __doc__ = """ :mod:`volumential` can compute 2/3D volume potentials using FMM. """ code_cache = WriteOncePersistentDict("volumential-code-cache-v0-" + VERSION_TEXT) # {{{ optimization control OPT_ENABLED = True OPT_ENABLED = "VOLUMENTIAL_NO_OPT" not in os.environ def set_optimization_enabled(flag): """Set whether the :mod:`loopy` kernels should be optimized.""" global OPT_ENABLED OPT_ENABLED = flag # }}}