Function FindInFileRange

src/OSTPlatform/Windows/ByteSearch.cpp:97–269

}

std::optional<uint64_t> FindInFileRange(
    const std::filesystem::path& path,
    uint64_t offset,
    uint64_t size,
    std::span<const uint8_t> pattern,
    size_t chunkBytes) {
    const Stopwatch totalTimer;
    FixedPatternScanner scanner(pattern);
    const size_t patternSize = scanner.PatternSize();
    if (patternSize == 0 || size == 0) return std::nullopt;

    Windows::UniqueFileHandle file = OpenForOverlappedSequentialRead(path);
    if (!file) {
        OSTP_LOG_DEBUG("ByteSearch::FindInFileRange open failed path={} offset=0x{:X} size={} err={}",
                       path.string(), offset, size, ::GetLastError());
        return std::nullopt;
    }

    LARGE_INTEGER sizeLi{};
    if (!::GetFileSizeEx(file.get(), &sizeLi) || sizeLi.QuadPart <= 0) {
        OSTP_LOG_DEBUG("ByteSearch::FindInFileRange empty/invalid file path={} offset=0x{:X} size={}",
                       path.string(), offset, size);
        return std::nullopt;
    }

    const uint64_t fileSize = static_cast<uint64_t>(sizeLi.QuadPart);
    if (offset >= fileSize) {
        OSTP_LOG_DEBUG("ByteSearch::FindInFileRange offset past EOF path={} offset=0x{:X} file_size={}",
                       path.string(), offset, fileSize);
        return std::nullopt;
    }

    const uint64_t rangeEnd = offset + (std::min)(size, fileSize - offset);

    chunkBytes = (std::max)(chunkBytes, patternSize);
    // Consecutive chunks overlap by (patternSize - 1) bytes: a match straddling a
    // chunk boundary runs off chunk i's tail (BMH won't see it there) but is fully
    // contained at the head of chunk i+1. Because the overlap is re-read from disk
    // rather than carry-copied from the previous buffer, the read of chunk i+1 has
    // no data dependency on the scan of chunk i — so the two can truly overlap.
    const uint64_t stride = static_cast<uint64_t>(chunkBytes) - (patternSize - 1);

    // Double buffering: while BMH scans chunk i in one buffer, the kernel streams
    // chunk i+1 into the other. make_unique_for_overwrite skips the zero-fill the
    // buffers are about to be overwritten anyway.
    std::unique_ptr<uint8_t[]> buffers[2] = {
        std::make_unique_for_overwrite<uint8_t[]>(chunkBytes),
        std::make_unique_for_overwrite<uint8_t[]>(chunkBytes),
    };
    Windows::UniqueHandle events[2] = {
        Windows::UniqueHandle(::CreateEventW(nullptr, TRUE, FALSE, nullptr)),
        Windows::UniqueHandle(::CreateEventW(nullptr, TRUE, FALSE, nullptr)),
    };
    if (!events[0] || !events[1]) {
        OSTP_LOG_DEBUG("ByteSearch::FindInFileRange event create failed path={} err={}",
                       path.string(), ::GetLastError());
        return std::nullopt;
    }