File size: 3,968 Bytes
37b1a0f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
"""Process ownership and durable publication for the local feature store.

Locks are kernel-owned, not PID files, and release when a process exits. Lock files stay
in place: unlinking one would let another process lock a different inode at the same path.
See https://docs.python.org/3/library/fcntl.html and
https://www.sqlite.org/atomiccommit.html for the locking and flush assumptions.
"""

from __future__ import annotations

import errno
import os
import time

from collections.abc import Iterator
from contextlib import contextmanager
from pathlib import Path
from typing import BinaryIO


@contextmanager
def file_lock(path: Path, *, wait: bool = True) -> Iterator[None]:
    """Hold a process lock on a stable file, optionally refusing a competing owner."""
    path.parent.mkdir(parents=True, exist_ok=True)
    owner_pid = os.getpid()
    with path.open("a+b") as handle:
        if os.name == "nt":
            import msvcrt

            while True:
                try:
                    handle.seek(0)
                    msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
                    break
                except OSError as error:
                    if error.errno not in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
                        raise
                    if not wait:
                        raise BlockingIOError(
                            "Feature segment already has an active writer."
                        ) from error
                    time.sleep(0.05)
            try:
                yield
            finally:
                if os.getpid() == owner_pid:
                    handle.seek(0)
                    msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
        else:
            import fcntl

            flags = fcntl.LOCK_EX | (0 if wait else fcntl.LOCK_NB)
            try:
                fcntl.flock(handle.fileno(), flags)
            except BlockingIOError as error:
                raise BlockingIOError("Feature segment already has an active writer.") from error
            try:
                yield
            finally:
                if os.getpid() == owner_pid:
                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)


def sync_directory(path: Path) -> None:
    """Flush directory entries on POSIX; Windows has no equivalent directory fsync."""
    if os.name != "nt":
        descriptor = os.open(path, os.O_RDONLY | os.O_DIRECTORY)
        try:
            os.fsync(descriptor)
        finally:
            os.close(descriptor)


def flush_and_evict(handle: BinaryIO) -> None:
    """Make a written file durable, then drop its pages from the page cache.

    A feature store writes far more than it reads back soon, and written pages stay cached. On a GH200 the
    kernel fills the GPU's HBM, which Linux exposes as a NUMA node, with that cache, so ``nvidia-smi`` reads
    the device as full and the next large allocation waits while the kernel evicts. The pages are clean
    after ``fsync``, so ``POSIX_FADV_DONTNEED`` drops all of them. Windows has no ``posix_fadvise`` and
    keeps only the flush. Callers flush Python buffers first.
    """
    descriptor = handle.fileno()
    os.fsync(descriptor)
    if hasattr(os, "posix_fadvise"):
        os.posix_fadvise(descriptor, 0, 0, os.POSIX_FADV_DONTNEED)  # offset 0, length 0: the whole file


def publish_file(temporary: Path, destination: Path, *, sync_parent: bool = True) -> None:
    """Flush a complete staged file, rename it, then flush its containing directory.

    A caller that publishes many files into one directory passes ``sync_parent=False`` and flushes the
    directory once, before the commit marker, so a part costs one flush and not two. The staged file
    leaves the page cache once it is durable (``flush_and_evict``).
    """
    with temporary.open("r+b") as handle:
        flush_and_evict(handle)
    temporary.replace(destination)
    if sync_parent:
        sync_directory(destination.parent)