Datasets:
Formats:
parquet
Size:
100K - 1M
Tags:
population-genetics
demographic-inference
effective-population-size
coalescent
msprime
simulation
License:
| from __future__ import annotations | |
| from dataclasses import dataclass, fields | |
| from multiprocessing import shared_memory | |
| from typing import Any | |
| import numpy as np | |
| from .empirical_maps import EmpiricalMapStore, PiecewiseRateMap | |
| class SharedArraySpec: | |
| offset: int | |
| shape: tuple[int, ...] | |
| dtype: str | |
| class SharedPiecewiseRateMapSpec: | |
| attributes: dict[str, Any] | |
| position: SharedArraySpec | |
| rate: SharedArraySpec | |
| class SharedEmpiricalMapStoreSpec: | |
| memory_name: str | None | |
| memory_size: int | |
| rec_maps: dict[str, SharedPiecewiseRateMapSpec] | |
| mut_maps: dict[str, SharedPiecewiseRateMapSpec] | |
| metadata: dict[str, dict] | |
| common_span_cache: dict[str, tuple[float, float]] | |
| usable_chrom_cache: dict[float, tuple[str, ...]] | |
| def _piecewise_attributes(rate_map: PiecewiseRateMap) -> dict[str, Any]: | |
| return { | |
| field.name: getattr(rate_map, field.name) | |
| for field in fields(PiecewiseRateMap) | |
| if field.name not in {"position", "rate"} | |
| } | |
| def _layout_array(array: np.ndarray, offset: int) -> tuple[SharedArraySpec, int]: | |
| value = np.asarray(array) | |
| if value.dtype.hasobject: | |
| raise TypeError("empirical map arrays must not use object dtype") | |
| alignment = max(1, int(value.dtype.alignment)) | |
| aligned_offset = ((offset + alignment - 1) // alignment) * alignment | |
| spec = SharedArraySpec( | |
| offset=aligned_offset, | |
| shape=tuple(int(size) for size in value.shape), | |
| dtype=value.dtype.str, | |
| ) | |
| return spec, aligned_offset + int(value.nbytes) | |
| def _layout_maps( | |
| maps: dict[str, PiecewiseRateMap], | |
| offset: int, | |
| ) -> tuple[dict[str, SharedPiecewiseRateMapSpec], int]: | |
| out: dict[str, SharedPiecewiseRateMapSpec] = {} | |
| for chrom, rate_map in maps.items(): | |
| position_spec, offset = _layout_array(rate_map.position, offset) | |
| rate_spec, offset = _layout_array(rate_map.rate, offset) | |
| out[chrom] = SharedPiecewiseRateMapSpec( | |
| attributes=_piecewise_attributes(rate_map), | |
| position=position_spec, | |
| rate=rate_spec, | |
| ) | |
| return out, offset | |
| def _copy_array( | |
| array: np.ndarray, | |
| spec: SharedArraySpec, | |
| shm: shared_memory.SharedMemory, | |
| ) -> None: | |
| source = np.ascontiguousarray(array) | |
| view = np.ndarray( | |
| spec.shape, | |
| dtype=np.dtype(spec.dtype), | |
| buffer=shm.buf, | |
| offset=spec.offset, | |
| ) | |
| view[...] = source | |
| def _copy_maps( | |
| maps: dict[str, PiecewiseRateMap], | |
| specs: dict[str, SharedPiecewiseRateMapSpec], | |
| shm: shared_memory.SharedMemory, | |
| ) -> None: | |
| for chrom, rate_map in maps.items(): | |
| spec = specs[chrom] | |
| _copy_array(rate_map.position, spec.position, shm) | |
| _copy_array(rate_map.rate, spec.rate, shm) | |
| def create_shared_empirical_map_store( | |
| store: EmpiricalMapStore, | |
| ) -> tuple[SharedEmpiricalMapStoreSpec, list[shared_memory.SharedMemory]]: | |
| """Copy all empirical arrays into one shared-memory segment.""" | |
| rec_specs, offset = _layout_maps(store.rec_maps, 0) | |
| mut_specs, memory_size = _layout_maps(store.mut_maps, offset) | |
| if memory_size == 0: | |
| return ( | |
| SharedEmpiricalMapStoreSpec( | |
| memory_name=None, | |
| memory_size=0, | |
| rec_maps=rec_specs, | |
| mut_maps=mut_specs, | |
| metadata=store.metadata, | |
| common_span_cache=dict(store._common_span_cache), | |
| usable_chrom_cache=dict(store._usable_chrom_cache), | |
| ), | |
| [], | |
| ) | |
| shm = shared_memory.SharedMemory(create=True, size=memory_size) | |
| try: | |
| _copy_maps(store.rec_maps, rec_specs, shm) | |
| _copy_maps(store.mut_maps, mut_specs, shm) | |
| spec = SharedEmpiricalMapStoreSpec( | |
| memory_name=shm.name, | |
| memory_size=memory_size, | |
| rec_maps=rec_specs, | |
| mut_maps=mut_specs, | |
| metadata=store.metadata, | |
| common_span_cache=dict(store._common_span_cache), | |
| usable_chrom_cache=dict(store._usable_chrom_cache), | |
| ) | |
| except Exception: | |
| shm.close() | |
| shm.unlink() | |
| raise | |
| return spec, [shm] | |
| def _attach_array( | |
| spec: SharedArraySpec, | |
| shm: shared_memory.SharedMemory, | |
| ) -> np.ndarray: | |
| array = np.ndarray( | |
| spec.shape, | |
| dtype=np.dtype(spec.dtype), | |
| buffer=shm.buf, | |
| offset=spec.offset, | |
| ) | |
| array.flags.writeable = False | |
| return array | |
| def _attach_piecewise_map( | |
| spec: SharedPiecewiseRateMapSpec, | |
| shm: shared_memory.SharedMemory, | |
| ) -> PiecewiseRateMap: | |
| return PiecewiseRateMap( | |
| position=_attach_array(spec.position, shm), | |
| rate=_attach_array(spec.rate, shm), | |
| **spec.attributes, | |
| ) | |
| def attach_shared_empirical_map_store( | |
| spec: SharedEmpiricalMapStoreSpec, | |
| ) -> tuple[EmpiricalMapStore, list[shared_memory.SharedMemory]]: | |
| """Attach read-only NumPy views to a shared empirical map store.""" | |
| if spec.memory_name is None: | |
| if spec.memory_size != 0 or spec.rec_maps or spec.mut_maps: | |
| raise ValueError("shared empirical map specification is missing its memory segment") | |
| return ( | |
| EmpiricalMapStore( | |
| metadata=spec.metadata, | |
| _common_span_cache=dict(spec.common_span_cache), | |
| _usable_chrom_cache=dict(spec.usable_chrom_cache), | |
| ), | |
| [], | |
| ) | |
| shm = shared_memory.SharedMemory(name=spec.memory_name) | |
| try: | |
| store = EmpiricalMapStore( | |
| rec_maps={ | |
| chrom: _attach_piecewise_map(map_spec, shm) | |
| for chrom, map_spec in spec.rec_maps.items() | |
| }, | |
| mut_maps={ | |
| chrom: _attach_piecewise_map(map_spec, shm) | |
| for chrom, map_spec in spec.mut_maps.items() | |
| }, | |
| metadata=spec.metadata, | |
| _common_span_cache=dict(spec.common_span_cache), | |
| _usable_chrom_cache=dict(spec.usable_chrom_cache), | |
| ) | |
| except Exception: | |
| shm.close() | |
| raise | |
| return store, [shm] | |
| def release_shared_memory( | |
| handles: list[shared_memory.SharedMemory], | |
| *, | |
| unlink: bool = False, | |
| ) -> None: | |
| for shm in handles: | |
| try: | |
| shm.close() | |
| except FileNotFoundError: | |
| pass | |
| if unlink: | |
| try: | |
| shm.unlink() | |
| except FileNotFoundError: | |
| pass | |