/src/llama.cpp/src/llama-mmap.cpp

Source
#include "llama-mmap.h"

#include "llama-impl.h"

#include "ggml.h"

#include <cstring>
#include <climits>
#include <stdexcept>
#include <cerrno>
#include <algorithm>

#ifdef __has_include
    #if __has_include(<unistd.h>)
        #include <unistd.h>
        #if defined(_POSIX_MAPPED_FILES)
            #include <sys/mman.h>
            #include <fcntl.h>
        #endif
        #if defined(_POSIX_MEMLOCK_RANGE)
            #include <sys/resource.h>
        #endif
    #endif
#endif

#if defined(_WIN32)
    #define WIN32_LEAN_AND_MEAN
    #ifndef NOMINMAX
        #define NOMINMAX
    #endif
    #include <windows.h>
    #ifndef PATH_MAX
        #define PATH_MAX MAX_PATH
    #endif
    #include <io.h>
#endif

#if defined(__APPLE__)
#include <TargetConditionals.h>
#endif

// TODO: consider moving to llama-impl.h if needed in more places
#if defined(_WIN32)
static std::string llama_format_win_err(DWORD err) {
    LPSTR buf;
    size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                 NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&buf, 0, NULL);
    if (!size) {
        return "FormatMessageA failed";
    }
    std::string ret(buf, size);
    LocalFree(buf);
    return ret;
}
#endif

// llama_file

struct llama_file::impl {
#if defined(_WIN32)
    HANDLE fp_win32;
    std::string GetErrorMessageWin32(DWORD error_code) const {
        std::string ret;
        LPSTR lpMsgBuf = NULL;
        DWORD bufLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpMsgBuf, 0, NULL);
        if (!bufLen) {
            ret = format("Win32 error code: %lx", error_code);
        } else {
            ret = lpMsgBuf;
            LocalFree(lpMsgBuf);
        }

        return ret;
    }

    impl(const char * fname, const char * mode) {
        fp = ggml_fopen(fname, mode);
        if (fp == NULL) {
            throw std::runtime_error(format("failed to open %s: %s", fname, strerror(errno)));
        }
        fp_win32 = (HANDLE) _get_osfhandle(_fileno(fp));
        seek(0, SEEK_END);
        size = tell();
        seek(0, SEEK_SET);
    }

    size_t tell() const {
        LARGE_INTEGER li;
        li.QuadPart = 0;
        BOOL ret = SetFilePointerEx(fp_win32, li, &li, FILE_CURRENT);
        if (!ret) {
            throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
        }

        return li.QuadPart;
    }

    void seek(size_t offset, int whence) const {
        static_assert(SEEK_SET == FILE_BEGIN, "SEEK_SET != FILE_BEGIN");
        static_assert(SEEK_CUR == FILE_CURRENT, "SEEK_CUR != FILE_CURRENT");
        static_assert(SEEK_END == FILE_END, "SEEK_END != FILE_END");

        LARGE_INTEGER li;
        li.QuadPart = offset;
        BOOL ret = SetFilePointerEx(fp_win32, li, NULL, whence);
        if (!ret) {
            throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
        }
    }

    void read_raw(void * ptr, size_t len) const {
        size_t bytes_read = 0;
        while (bytes_read < len) {
            size_t chunk_size = std::min<size_t>(len - bytes_read, 64*1024*1024);
            DWORD chunk_read = 0;
            BOOL result = ReadFile(fp_win32, reinterpret_cast<char*>(ptr) + bytes_read, chunk_size, &chunk_read, NULL);
            if (!result) {
                throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
            }
            if (chunk_read < chunk_size || chunk_read == 0) {
                throw std::runtime_error("unexpectedly reached end of file");
            }

            bytes_read += chunk_read;
        }
    }

    uint32_t read_u32() const {
        uint32_t val;
        read_raw(&val, sizeof(val));
        return val;
    }

    void write_raw(const void * ptr, size_t len) const {
        size_t bytes_written = 0;
        while (bytes_written < len) {
            size_t chunk_size = std::min<size_t>(len - bytes_written, 64*1024*1024);
            DWORD chunk_written = 0;
            BOOL result = WriteFile(fp_win32, reinterpret_cast<char const*>(ptr) + bytes_written, chunk_size, &chunk_written, NULL);
            if (!result) {
                throw std::runtime_error(format("write error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
            }
            if (chunk_written < chunk_size || chunk_written == 0) {
                throw std::runtime_error("unexpectedly failed to write bytes");
            }

            bytes_written += chunk_written;
        }
    }

    void write_u32(uint32_t val) const {
        write_raw(&val, sizeof(val));
    }

    ~impl() {
        if (fp) {
            std::fclose(fp);
        }
    }
#else
    impl(const char * fname, const char * mode) {
        fp = ggml_fopen(fname, mode);
        if (fp == NULL) {
            throw std::runtime_error(format("failed to open %s: %s", fname, strerror(errno)));
        }
        seek(0, SEEK_END);
        size = tell();
        seek(0, SEEK_SET);
    }

    size_t tell() const {
// TODO: this ifdef is never true?
#ifdef _WIN32
        __int64 ret = _ftelli64(fp);
#else
        long ret = std::ftell(fp);
#endif
        if (ret == -1) {
            throw std::runtime_error(format("ftell error: %s", strerror(errno)));
        }

        return (size_t) ret;
    }

    void seek(size_t offset, int whence) const {
// TODO: this ifdef is never true?
#ifdef _WIN32
        int ret = _fseeki64(fp, (__int64) offset, whence);
#else
        int ret = std::fseek(fp, (long) offset, whence);
#endif
        if (ret != 0) {
            throw std::runtime_error(format("seek error: %s", strerror(errno)));
        }
    }

    void read_raw(void * ptr, size_t len) const {
        if (len == 0) {
            return;
        }
        errno = 0;
        std::size_t ret = std::fread(ptr, len, 1, fp);
        if (ferror(fp)) {
            throw std::runtime_error(format("read error: %s", strerror(errno)));
        }
        if (ret != 1) {
            throw std::runtime_error("unexpectedly reached end of file");
        }
    }

    uint32_t read_u32() const {
        uint32_t ret;
        read_raw(&ret, sizeof(ret));
        return ret;
    }

    void write_raw(const void * ptr, size_t len) const {
        if (len == 0) {
            return;
        }
        errno = 0;
        size_t ret = std::fwrite(ptr, len, 1, fp);
        if (ret != 1) {
            throw std::runtime_error(format("write error: %s", strerror(errno)));
        }
    }

    void write_u32(uint32_t val) const {
        write_raw(&val, sizeof(val));
    }

    ~impl() {
        if (fp) {
            std::fclose(fp);
        }
    }
#endif

    FILE * fp;
    size_t size;
};

llama_file::llama_file(const char * fname, const char * mode) : pimpl(std::make_unique<impl>(fname, mode)) {}
llama_file::~llama_file() = default;

size_t llama_file::tell() const { return pimpl->tell(); }
size_t llama_file::size() const { return pimpl->size; }

int llama_file::file_id() const {
#ifdef _WIN32
    return _fileno(pimpl->fp);
#else
#if defined(fileno)
    return fileno(pimpl->fp);
#else
    return ::fileno(pimpl->fp);
#endif
#endif
}

void llama_file::seek(size_t offset, int whence) const { pimpl->seek(offset, whence); }
void llama_file::read_raw(void * ptr, size_t len) const { pimpl->read_raw(ptr, len); }

uint32_t llama_file::read_u32() const { return pimpl->read_u32(); }

void llama_file::write_raw(const void * ptr, size_t len) const { pimpl->write_raw(ptr, len); }
void llama_file::write_u32(uint32_t val) const { pimpl->write_u32(val); }

// llama_mmap

struct llama_mmap::impl {
#ifdef _POSIX_MAPPED_FILES
    std::vector<std::pair<size_t, size_t>> mapped_fragments;

    impl(struct llama_file * file, size_t prefetch, bool numa) {
        size = file->size();
        int fd = file->file_id();
        int flags = MAP_SHARED;
        if (numa) { prefetch = 0; }
#ifdef __linux__
        if (posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL)) {
            LLAMA_LOG_WARN("warning: posix_fadvise(.., POSIX_FADV_SEQUENTIAL) failed: %s\n",
                    strerror(errno));
        }
        if (prefetch) { flags |= MAP_POPULATE; }
#endif
        addr = mmap(NULL, file->size(), PROT_READ, flags, fd, 0);
        if (addr == MAP_FAILED) {
            throw std::runtime_error(format("mmap failed: %s", strerror(errno)));
        }

        if (prefetch > 0) {
            if (posix_madvise(addr, std::min(file->size(), prefetch), POSIX_MADV_WILLNEED)) {
                LLAMA_LOG_WARN("warning: posix_madvise(.., POSIX_MADV_WILLNEED) failed: %s\n",
                        strerror(errno));
            }
        }
        if (numa) {
            if (posix_madvise(addr, file->size(), POSIX_MADV_RANDOM)) {
                LLAMA_LOG_WARN("warning: posix_madvise(.., POSIX_MADV_RANDOM) failed: %s\n",
                        strerror(errno));
            }
        }

        mapped_fragments.emplace_back(0, file->size());
    }

    static void align_range(size_t * first, size_t * last, size_t page_size) {
        size_t offset_in_page = *first & (page_size - 1);
        size_t offset_to_page = offset_in_page == 0 ? 0 : page_size - offset_in_page;
        *first += offset_to_page;

        *last = *last & ~(page_size - 1);

        if (*last <= *first) {
            *last = *first;
        }
    }

    void unmap_fragment(size_t first, size_t last) {
        int page_size = sysconf(_SC_PAGESIZE);
        align_range(&first, &last, page_size);
        size_t len = last - first;

        if (len == 0) {
            return;
        }

        GGML_ASSERT(first % page_size == 0);
        GGML_ASSERT(last % page_size == 0);
        GGML_ASSERT(last > first);

        void * next_page_start = (uint8_t *) addr + first;

        if (munmap(next_page_start, len)) {
            LLAMA_LOG_WARN("warning: munmap failed: %s\n", strerror(errno));
        }

        std::vector<std::pair<size_t, size_t>> new_mapped_fragments;
        for (const auto & frag : mapped_fragments) {
            if (frag.first < first && frag.second > last) {
                new_mapped_fragments.emplace_back(frag.first, first);
                new_mapped_fragments.emplace_back(last, frag.second);
            } else if (frag.first < first && frag.second > first) {
                new_mapped_fragments.emplace_back(frag.first, first);
            } else if (frag.first < last && frag.second > last) {
                new_mapped_fragments.emplace_back(last, frag.second);
            } else if (frag.first >= first && frag.second <= last) {
            } else {
                new_mapped_fragments.push_back(frag);
            }
        }
        mapped_fragments = std::move(new_mapped_fragments);
    }

    ~impl() {
        for (const auto & frag : mapped_fragments) {
            if (munmap((char *) addr + frag.first, frag.second - frag.first)) {
                LLAMA_LOG_WARN("warning: munmap failed: %s\n", strerror(errno));
            }
        }
    }
#elif defined(_WIN32)
    impl(struct llama_file * file, size_t prefetch, bool numa) {
        GGML_UNUSED(numa);

        size = file->size();

        HANDLE hFile = (HANDLE) _get_osfhandle(file->file_id());

        HANDLE hMapping = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL);

        if (hMapping == NULL) {
            DWORD error = GetLastError();
            throw std::runtime_error(format("CreateFileMappingA failed: %s", llama_format_win_err(error).c_str()));
        }

        addr = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
        DWORD error = GetLastError();
        CloseHandle(hMapping);

        if (addr == NULL) {
            throw std::runtime_error(format("MapViewOfFile failed: %s", llama_format_win_err(error).c_str()));
        }

        if (prefetch > 0) {
#if _WIN32_WINNT >= 0x602
            BOOL (WINAPI *pPrefetchVirtualMemory) (HANDLE, ULONG_PTR, PWIN32_MEMORY_RANGE_ENTRY, ULONG);
            HMODULE hKernel32 = GetModuleHandleW(L"kernel32.dll");

            pPrefetchVirtualMemory = (decltype(pPrefetchVirtualMemory))(void *) GetProcAddress(hKernel32, "PrefetchVirtualMemory");

            if (pPrefetchVirtualMemory) {
                WIN32_MEMORY_RANGE_ENTRY range;
                range.VirtualAddress = addr;
                range.NumberOfBytes = (SIZE_T) std::min(size, prefetch);
                if (!pPrefetchVirtualMemory(GetCurrentProcess(), 1, &range, 0)) {
                    LLAMA_LOG_WARN("warning: PrefetchVirtualMemory failed: %s\n",
                            llama_format_win_err(GetLastError()).c_str());
                }
            }
#else
            LLAMA_LOG_DEBUG("skipping PrefetchVirtualMemory because _WIN32_WINNT < 0x602\n");
#endif
        }
    }

    void unmap_fragment(size_t first, size_t last) {
        GGML_UNUSED(first);
        GGML_UNUSED(last);
    }

    ~impl() {
        if (!UnmapViewOfFile(addr)) {
            LLAMA_LOG_WARN("warning: UnmapViewOfFile failed: %s\n",
                    llama_format_win_err(GetLastError()).c_str());
        }
    }
#else
    impl(struct llama_file * file, size_t prefetch, bool numa) {
        GGML_UNUSED(file);
        GGML_UNUSED(prefetch);
        GGML_UNUSED(numa);

        throw std::runtime_error("mmap not supported");
    }

    void unmap_fragment(size_t first, size_t last) {
        GGML_UNUSED(first);
        GGML_UNUSED(last);

        throw std::runtime_error("mmap not supported");
    }
#endif

    void * addr;
    size_t size;
};

llama_mmap::llama_mmap(struct llama_file * file, size_t prefetch, bool numa) : pimpl(std::make_unique<impl>(file, prefetch, numa)) {}
llama_mmap::~llama_mmap() = default;

size_t llama_mmap::size() const { return pimpl->size; }
void * llama_mmap::addr() const { return pimpl->addr; }

void llama_mmap::unmap_fragment(size_t first, size_t last) { pimpl->unmap_fragment(first, last); }

#if defined(_POSIX_MEMLOCK_RANGE) || defined(_WIN32)
const bool llama_mmap::SUPPORTED  = true;
#else
const bool llama_mmap::SUPPORTED  = false;
#endif

// llama_mlock

struct llama_mlock::impl {
#ifdef _POSIX_MEMLOCK_RANGE
    static size_t lock_granularity() {
        return (size_t) sysconf(_SC_PAGESIZE);
    }

    bool raw_lock(const void * addr, size_t size) const {
        if (!mlock(addr, size)) {
            return true;
        }

#ifdef __APPLE__
#define MLOCK_SUGGESTION \
        "Try increasing the sysctl values 'vm.user_wire_limit' and 'vm.global_user_wire_limit' and/or " \
        "decreasing 'vm.global_no_user_wire_amount'.  Also try increasing RLIMIT_MEMLOCK (ulimit -l).\n"
#else
#define MLOCK_SUGGESTION \
        "Try increasing RLIMIT_MEMLOCK ('ulimit -l' as root).\n"
#endif

        char* errmsg = std::strerror(errno);
        bool suggest = (errno == ENOMEM);
#if defined(TARGET_OS_VISION) || defined(TARGET_OS_TV) || defined(_AIX)
        // visionOS/tvOS dont't support RLIMIT_MEMLOCK
        // Skip resource limit checks on visionOS/tvOS
        suggest = false;
#else
        struct rlimit lock_limit;
        if (suggest && getrlimit(RLIMIT_MEMLOCK, &lock_limit)) {
            suggest = false;
        }
        if (suggest && (lock_limit.rlim_max > lock_limit.rlim_cur + size)) {
            suggest = false;
        }
#endif

        LLAMA_LOG_WARN("warning: failed to mlock %zu-byte buffer (after previously locking %zu bytes): %s\n%s",
                size, this->size, errmsg, suggest ? MLOCK_SUGGESTION : "");
        return false;
    }

    static void raw_unlock(void * addr, size_t size) {
        if (munlock(addr, size)) {
            LLAMA_LOG_WARN("warning: failed to munlock buffer: %s\n", std::strerror(errno));
        }
    }
#elif defined(_WIN32)
    static size_t lock_granularity() {
        SYSTEM_INFO si;
        GetSystemInfo(&si);
        return (size_t) si.dwPageSize;
    }

    bool raw_lock(void * ptr, size_t len) const {
        for (int tries = 1; ; tries++) {
            if (VirtualLock(ptr, len)) {
                return true;
            }
            if (tries == 2) {
                LLAMA_LOG_WARN("warning: failed to VirtualLock %zu-byte buffer (after previously locking %zu bytes): %s\n",
                    len, size, llama_format_win_err(GetLastError()).c_str());
                return false;
            }

            SIZE_T min_ws_size, max_ws_size;
            if (!GetProcessWorkingSetSize(GetCurrentProcess(), &min_ws_size, &max_ws_size)) {
                LLAMA_LOG_WARN("warning: GetProcessWorkingSetSize failed: %s\n",
                        llama_format_win_err(GetLastError()).c_str());
                return false;
            }
            size_t increment = len + 1048576;
            min_ws_size += increment;
            max_ws_size += increment;
            if (!SetProcessWorkingSetSize(GetCurrentProcess(), min_ws_size, max_ws_size)) {
                LLAMA_LOG_WARN("warning: SetProcessWorkingSetSize failed: %s\n",
                        llama_format_win_err(GetLastError()).c_str());
                return false;
            }
        }
    }

    static void raw_unlock(void * ptr, size_t len) {
        if (!VirtualUnlock(ptr, len)) {
            LLAMA_LOG_WARN("warning: failed to VirtualUnlock buffer: %s\n",
                    llama_format_win_err(GetLastError()).c_str());
        }
    }
#else
    static size_t lock_granularity() {
        return (size_t) 65536;
    }

    bool raw_lock(const void * addr, size_t len) const {
        LLAMA_LOG_WARN("warning: mlock not supported on this system\n");
        return false;
    }

    static void raw_unlock(const void * addr, size_t len) {}
#endif

    impl() : addr(NULL), size(0), failed_already(false) {}

    void init(void * ptr) {
        GGML_ASSERT(addr == NULL && size == 0);
        addr = ptr;
    }

    void grow_to(size_t target_size) {
        GGML_ASSERT(addr);
        if (failed_already) {
            return;
        }
        size_t granularity = lock_granularity();
        target_size = (target_size + granularity - 1) & ~(granularity - 1);
        if (target_size > size) {
            if (raw_lock((uint8_t *) addr + size, target_size - size)) {
                size = target_size;
            } else {
                failed_already = true;
            }
        }
    }

    void * addr;
    size_t size;

    bool failed_already;
};

llama_mlock::llama_mlock() : pimpl(std::make_unique<impl>()) {}
llama_mlock::~llama_mlock() = default;

void llama_mlock::init(void * ptr) { pimpl->init(ptr); }
void llama_mlock::grow_to(size_t target_size) { pimpl->grow_to(target_size); }

#if defined(_POSIX_MEMLOCK_RANGE) || defined(_WIN32)
const bool llama_mlock::SUPPORTED = true;
#else
const bool llama_mlock::SUPPORTED = false;
#endif

size_t llama_path_max() {
    return PATH_MAX;
}

Coverage Report

Created: 2025-11-28 06:57

Line	Count	Source
1		#include "llama-mmap.h"
2
3		#include "llama-impl.h"
4
5		#include "ggml.h"
6
7		#include <cstring>
8		#include <climits>
9		#include <stdexcept>
10		#include <cerrno>
11		#include <algorithm>
12
13		#ifdef __has_include
14		#if __has_include(<unistd.h>)
15		#include <unistd.h>
16		#if defined(_POSIX_MAPPED_FILES)
17		#include <sys/mman.h>
18		#include <fcntl.h>
19		#endif
20		#if defined(_POSIX_MEMLOCK_RANGE)
21		#include <sys/resource.h>
22		#endif
23		#endif
24		#endif
25
26		#if defined(_WIN32)
27		#define WIN32_LEAN_AND_MEAN
28		#ifndef NOMINMAX
29		#define NOMINMAX
30		#endif
31		#include <windows.h>
32		#ifndef PATH_MAX
33		#define PATH_MAX MAX_PATH
34		#endif
35		#include <io.h>
36		#endif
37
38		#if defined(__APPLE__)
39		#include <TargetConditionals.h>
40		#endif
41
42		// TODO: consider moving to llama-impl.h if needed in more places
43		#if defined(_WIN32)
44		static std::string llama_format_win_err(DWORD err) {
45		LPSTR buf;
46		size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS,
47		NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&buf, 0, NULL);
48		if (!size) {
49		return "FormatMessageA failed";
50		}
51		std::string ret(buf, size);
52		LocalFree(buf);
53		return ret;
54		}
55		#endif
56
57		// llama_file
58
59		struct llama_file::impl {
60		#if defined(_WIN32)
61		HANDLE fp_win32;
62		std::string GetErrorMessageWin32(DWORD error_code) const {
63		std::string ret;
64		LPSTR lpMsgBuf = NULL;
65		DWORD bufLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS,
66		NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpMsgBuf, 0, NULL);
67		if (!bufLen) {
68		ret = format("Win32 error code: %lx", error_code);
69		} else {
70		ret = lpMsgBuf;
71		LocalFree(lpMsgBuf);
72		}
73
74		return ret;
75		}
76
77		impl(const char * fname, const char * mode) {
78		fp = ggml_fopen(fname, mode);
79		if (fp == NULL) {
80		throw std::runtime_error(format("failed to open %s: %s", fname, strerror(errno)));
81		}
82		fp_win32 = (HANDLE) _get_osfhandle(_fileno(fp));
83		seek(0, SEEK_END);
84		size = tell();
85		seek(0, SEEK_SET);
86		}
87
88		size_t tell() const {
89		LARGE_INTEGER li;
90		li.QuadPart = 0;
91		BOOL ret = SetFilePointerEx(fp_win32, li, &li, FILE_CURRENT);
92		if (!ret) {
93		throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
94		}
95
96		return li.QuadPart;
97		}
98
99		void seek(size_t offset, int whence) const {
100		static_assert(SEEK_SET == FILE_BEGIN, "SEEK_SET != FILE_BEGIN");
101		static_assert(SEEK_CUR == FILE_CURRENT, "SEEK_CUR != FILE_CURRENT");
102		static_assert(SEEK_END == FILE_END, "SEEK_END != FILE_END");
103
104		LARGE_INTEGER li;
105		li.QuadPart = offset;
106		BOOL ret = SetFilePointerEx(fp_win32, li, NULL, whence);
107		if (!ret) {
108		throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
109		}
110		}
111
112		void read_raw(void * ptr, size_t len) const {
113		size_t bytes_read = 0;
114		while (bytes_read < len) {
115		size_t chunk_size = std::min<size_t>(len - bytes_read, 6410241024);
116		DWORD chunk_read = 0;
117		BOOL result = ReadFile(fp_win32, reinterpret_cast<char*>(ptr) + bytes_read, chunk_size, &chunk_read, NULL);
118		if (!result) {
119		throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
120		}
121		if (chunk_read < chunk_size \|\| chunk_read == 0) {
122		throw std::runtime_error("unexpectedly reached end of file");
123		}
124
125		bytes_read += chunk_read;
126		}
127		}
128
129		uint32_t read_u32() const {
130		uint32_t val;
131		read_raw(&val, sizeof(val));
132		return val;
133		}
134
135		void write_raw(const void * ptr, size_t len) const {
136		size_t bytes_written = 0;
137		while (bytes_written < len) {
138		size_t chunk_size = std::min<size_t>(len - bytes_written, 6410241024);
139		DWORD chunk_written = 0;
140		BOOL result = WriteFile(fp_win32, reinterpret_cast<char const*>(ptr) + bytes_written, chunk_size, &chunk_written, NULL);
141		if (!result) {
142		throw std::runtime_error(format("write error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
143		}
144		if (chunk_written < chunk_size \|\| chunk_written == 0) {
145		throw std::runtime_error("unexpectedly failed to write bytes");
146		}
147
148		bytes_written += chunk_written;
149		}
150		}
151
152		void write_u32(uint32_t val) const {
153		write_raw(&val, sizeof(val));
154		}
155
156		~impl() {
157		if (fp) {
158		std::fclose(fp);
159		}
160		}
161		#else
162	0	impl(const char * fname, const char * mode) {
163	0	fp = ggml_fopen(fname, mode);
164	0	if (fp == NULL) {
165	0	throw std::runtime_error(format("failed to open %s: %s", fname, strerror(errno)));
166	0	}
167	0	seek(0, SEEK_END);
168	0	size = tell();
169	0	seek(0, SEEK_SET);
170	0	}
171
172	0	size_t tell() const {
173		// TODO: this ifdef is never true?
174		#ifdef _WIN32
175		__int64 ret = _ftelli64(fp);
176		#else
177	0	long ret = std::ftell(fp);
178	0	#endif
179	0	if (ret == -1) {
180	0	throw std::runtime_error(format("ftell error: %s", strerror(errno)));
181	0	}
182
183	0	return (size_t) ret;
184	0	}
185
186	0	void seek(size_t offset, int whence) const {
187		// TODO: this ifdef is never true?
188		#ifdef _WIN32
189		int ret = _fseeki64(fp, (__int64) offset, whence);
190		#else
191	0	int ret = std::fseek(fp, (long) offset, whence);
192	0	#endif
193	0	if (ret != 0) {
194	0	throw std::runtime_error(format("seek error: %s", strerror(errno)));
195	0	}
196	0	}
197
198	0	void read_raw(void * ptr, size_t len) const {
199	0	if (len == 0) {
200	0	return;
201	0	}
202	0	errno = 0;
203	0	std::size_t ret = std::fread(ptr, len, 1, fp);
204	0	if (ferror(fp)) {
205	0	throw std::runtime_error(format("read error: %s", strerror(errno)));
206	0	}
207	0	if (ret != 1) {
208	0	throw std::runtime_error("unexpectedly reached end of file");
209	0	}
210	0	}
211
212	0	uint32_t read_u32() const {
213	0	uint32_t ret;
214	0	read_raw(&ret, sizeof(ret));
215	0	return ret;
216	0	}
217
218	0	void write_raw(const void * ptr, size_t len) const {
219	0	if (len == 0) {
220	0	return;
221	0	}
222	0	errno = 0;
223	0	size_t ret = std::fwrite(ptr, len, 1, fp);
224	0	if (ret != 1) {
225	0	throw std::runtime_error(format("write error: %s", strerror(errno)));
226	0	}
227	0	}
228
229	0	void write_u32(uint32_t val) const {
230	0	write_raw(&val, sizeof(val));
231	0	}
232
233	0	~impl() {
234	0	if (fp) {
235	0	std::fclose(fp);
236	0	}
237	0	}
238		#endif
239
240		FILE * fp;
241		size_t size;
242		};
243
244	0	llama_file::llama_file(const char * fname, const char * mode) : pimpl(std::make_unique<impl>(fname, mode)) {}
245	0	llama_file::~llama_file() = default;
246
247	0	size_t llama_file::tell() const { return pimpl->tell(); }
248	0	size_t llama_file::size() const { return pimpl->size; }
249
250	0	int llama_file::file_id() const {
251		#ifdef _WIN32
252		return _fileno(pimpl->fp);
253		#else
254		#if defined(fileno)
255		return fileno(pimpl->fp);
256		#else
257	0	return ::fileno(pimpl->fp);
258	0	#endif
259	0	#endif
260	0	}
261
262	0	void llama_file::seek(size_t offset, int whence) const { pimpl->seek(offset, whence); }
263	0	void llama_file::read_raw(void * ptr, size_t len) const { pimpl->read_raw(ptr, len); }
264
265	0	uint32_t llama_file::read_u32() const { return pimpl->read_u32(); }
266
267	0	void llama_file::write_raw(const void * ptr, size_t len) const { pimpl->write_raw(ptr, len); }
268	0	void llama_file::write_u32(uint32_t val) const { pimpl->write_u32(val); }
269
270		// llama_mmap
271
272		struct llama_mmap::impl {
273		#ifdef _POSIX_MAPPED_FILES
274		std::vector<std::pair<size_t, size_t>> mapped_fragments;
275
276	0	impl(struct llama_file * file, size_t prefetch, bool numa) {
277	0	size = file->size();
278	0	int fd = file->file_id();
279	0	int flags = MAP_SHARED;
280	0	if (numa) { prefetch = 0; }
281	0	#ifdef __linux__
282	0	if (posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL)) {
283	0	LLAMA_LOG_WARN("warning: posix_fadvise(.., POSIX_FADV_SEQUENTIAL) failed: %s\n",
284	0	strerror(errno));
285	0	}
286	0	if (prefetch) { flags \|= MAP_POPULATE; }
287	0	#endif
288	0	addr = mmap(NULL, file->size(), PROT_READ, flags, fd, 0);
289	0	if (addr == MAP_FAILED) {
290	0	throw std::runtime_error(format("mmap failed: %s", strerror(errno)));
291	0	}
292
293	0	if (prefetch > 0) {
294	0	if (posix_madvise(addr, std::min(file->size(), prefetch), POSIX_MADV_WILLNEED)) {
295	0	LLAMA_LOG_WARN("warning: posix_madvise(.., POSIX_MADV_WILLNEED) failed: %s\n",
296	0	strerror(errno));
297	0	}
298	0	}
299	0	if (numa) {
300	0	if (posix_madvise(addr, file->size(), POSIX_MADV_RANDOM)) {
301	0	LLAMA_LOG_WARN("warning: posix_madvise(.., POSIX_MADV_RANDOM) failed: %s\n",
302	0	strerror(errno));
303	0	}
304	0	}
305
306	0	mapped_fragments.emplace_back(0, file->size());
307	0	}
308
309	0	static void align_range(size_t * first, size_t * last, size_t page_size) {
310	0	size_t offset_in_page = *first & (page_size - 1);
311	0	size_t offset_to_page = offset_in_page == 0 ? 0 : page_size - offset_in_page;
312	0	*first += offset_to_page;
313
314	0	last = last & ~(page_size - 1);
315
316	0	if (last <= first) {
317	0	last = first;
318	0	}
319	0	}
320
321	0	void unmap_fragment(size_t first, size_t last) {
322	0	int page_size = sysconf(_SC_PAGESIZE);
323	0	align_range(&first, &last, page_size);
324	0	size_t len = last - first;
325
326	0	if (len == 0) {
327	0	return;
328	0	}
329
330	0	GGML_ASSERT(first % page_size == 0);
331	0	GGML_ASSERT(last % page_size == 0);
332	0	GGML_ASSERT(last > first);
333
334	0	void * next_page_start = (uint8_t *) addr + first;
335
336	0	if (munmap(next_page_start, len)) {
337	0	LLAMA_LOG_WARN("warning: munmap failed: %s\n", strerror(errno));
338	0	}
339
340	0	std::vector<std::pair<size_t, size_t>> new_mapped_fragments;
341	0	for (const auto & frag : mapped_fragments) {
342	0	if (frag.first < first && frag.second > last) {
343	0	new_mapped_fragments.emplace_back(frag.first, first);
344	0	new_mapped_fragments.emplace_back(last, frag.second);
345	0	} else if (frag.first < first && frag.second > first) {
346	0	new_mapped_fragments.emplace_back(frag.first, first);
347	0	} else if (frag.first < last && frag.second > last) {
348	0	new_mapped_fragments.emplace_back(last, frag.second);
349	0	} else if (frag.first >= first && frag.second <= last) {
350	0	} else {
351	0	new_mapped_fragments.push_back(frag);
352	0	}
353	0	}
354	0	mapped_fragments = std::move(new_mapped_fragments);
355	0	}
356
357	0	~impl() {
358	0	for (const auto & frag : mapped_fragments) {
359	0	if (munmap((char *) addr + frag.first, frag.second - frag.first)) {
360	0	LLAMA_LOG_WARN("warning: munmap failed: %s\n", strerror(errno));
361	0	}
362	0	}
363	0	}
364		#elif defined(_WIN32)
365		impl(struct llama_file * file, size_t prefetch, bool numa) {
366		GGML_UNUSED(numa);
367
368		size = file->size();
369
370		HANDLE hFile = (HANDLE) _get_osfhandle(file->file_id());
371
372		HANDLE hMapping = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
373
374		if (hMapping == NULL) {
375		DWORD error = GetLastError();
376		throw std::runtime_error(format("CreateFileMappingA failed: %s", llama_format_win_err(error).c_str()));
377		}
378
379		addr = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
380		DWORD error = GetLastError();
381		CloseHandle(hMapping);
382
383		if (addr == NULL) {
384		throw std::runtime_error(format("MapViewOfFile failed: %s", llama_format_win_err(error).c_str()));
385		}
386
387		if (prefetch > 0) {
388		#if _WIN32_WINNT >= 0x602
389		BOOL (WINAPI *pPrefetchVirtualMemory) (HANDLE, ULONG_PTR, PWIN32_MEMORY_RANGE_ENTRY, ULONG);
390		HMODULE hKernel32 = GetModuleHandleW(L"kernel32.dll");
391
392		pPrefetchVirtualMemory = (decltype(pPrefetchVirtualMemory))(void *) GetProcAddress(hKernel32, "PrefetchVirtualMemory");
393
394		if (pPrefetchVirtualMemory) {
395		WIN32_MEMORY_RANGE_ENTRY range;
396		range.VirtualAddress = addr;
397		range.NumberOfBytes = (SIZE_T) std::min(size, prefetch);
398		if (!pPrefetchVirtualMemory(GetCurrentProcess(), 1, &range, 0)) {
399		LLAMA_LOG_WARN("warning: PrefetchVirtualMemory failed: %s\n",
400		llama_format_win_err(GetLastError()).c_str());
401		}
402		}
403		#else
404		LLAMA_LOG_DEBUG("skipping PrefetchVirtualMemory because _WIN32_WINNT < 0x602\n");
405		#endif
406		}
407		}
408
409		void unmap_fragment(size_t first, size_t last) {
410		GGML_UNUSED(first);
411		GGML_UNUSED(last);
412		}
413
414		~impl() {
415		if (!UnmapViewOfFile(addr)) {
416		LLAMA_LOG_WARN("warning: UnmapViewOfFile failed: %s\n",
417		llama_format_win_err(GetLastError()).c_str());
418		}
419		}
420		#else
421		impl(struct llama_file * file, size_t prefetch, bool numa) {
422		GGML_UNUSED(file);
423		GGML_UNUSED(prefetch);
424		GGML_UNUSED(numa);
425
426		throw std::runtime_error("mmap not supported");
427		}
428
429		void unmap_fragment(size_t first, size_t last) {
430		GGML_UNUSED(first);
431		GGML_UNUSED(last);
432
433		throw std::runtime_error("mmap not supported");
434		}
435		#endif
436
437		void * addr;
438		size_t size;
439		};
440
441	0	llama_mmap::llama_mmap(struct llama_file * file, size_t prefetch, bool numa) : pimpl(std::make_unique<impl>(file, prefetch, numa)) {}
442	0	llama_mmap::~llama_mmap() = default;
443
444	0	size_t llama_mmap::size() const { return pimpl->size; }
445	0	void * llama_mmap::addr() const { return pimpl->addr; }
446
447	0	void llama_mmap::unmap_fragment(size_t first, size_t last) { pimpl->unmap_fragment(first, last); }
448
449		#if defined(_POSIX_MEMLOCK_RANGE) \|\| defined(_WIN32)
450		const bool llama_mmap::SUPPORTED = true;
451		#else
452		const bool llama_mmap::SUPPORTED = false;
453		#endif
454
455		// llama_mlock
456
457		struct llama_mlock::impl {
458		#ifdef _POSIX_MEMLOCK_RANGE
459	0	static size_t lock_granularity() {
460	0	return (size_t) sysconf(_SC_PAGESIZE);
461	0	}
462
463	0	bool raw_lock(const void * addr, size_t size) const {
464	0	if (!mlock(addr, size)) {
465	0	return true;
466	0	}
467
468		#ifdef __APPLE__
469		#define MLOCK_SUGGESTION \
470		"Try increasing the sysctl values 'vm.user_wire_limit' and 'vm.global_user_wire_limit' and/or " \
471		"decreasing 'vm.global_no_user_wire_amount'. Also try increasing RLIMIT_MEMLOCK (ulimit -l).\n"
472		#else
473	0	#define MLOCK_SUGGESTION \
474	0	"Try increasing RLIMIT_MEMLOCK ('ulimit -l' as root).\n"
475	0	#endif
476
477	0	char* errmsg = std::strerror(errno);
478	0	bool suggest = (errno == ENOMEM);
479		#if defined(TARGET_OS_VISION) \|\| defined(TARGET_OS_TV) \|\| defined(_AIX)
480		// visionOS/tvOS dont't support RLIMIT_MEMLOCK
481		// Skip resource limit checks on visionOS/tvOS
482		suggest = false;
483		#else
484	0	struct rlimit lock_limit;
485	0	if (suggest && getrlimit(RLIMIT_MEMLOCK, &lock_limit)) {
486	0	suggest = false;
487	0	}
488	0	if (suggest && (lock_limit.rlim_max > lock_limit.rlim_cur + size)) {
489	0	suggest = false;
490	0	}
491	0	#endif
492
493	0	LLAMA_LOG_WARN("warning: failed to mlock %zu-byte buffer (after previously locking %zu bytes): %s\n%s",
494	0	size, this->size, errmsg, suggest ? MLOCK_SUGGESTION : "");
495	0	return false;
496	0	}
497
498	0	static void raw_unlock(void * addr, size_t size) {
499	0	if (munlock(addr, size)) {
500	0	LLAMA_LOG_WARN("warning: failed to munlock buffer: %s\n", std::strerror(errno));
501	0	}
502	0	}
503		#elif defined(_WIN32)
504		static size_t lock_granularity() {
505		SYSTEM_INFO si;
506		GetSystemInfo(&si);
507		return (size_t) si.dwPageSize;
508		}
509
510		bool raw_lock(void * ptr, size_t len) const {
511		for (int tries = 1; ; tries++) {
512		if (VirtualLock(ptr, len)) {
513		return true;
514		}
515		if (tries == 2) {
516		LLAMA_LOG_WARN("warning: failed to VirtualLock %zu-byte buffer (after previously locking %zu bytes): %s\n",
517		len, size, llama_format_win_err(GetLastError()).c_str());
518		return false;
519		}
520
521		SIZE_T min_ws_size, max_ws_size;
522		if (!GetProcessWorkingSetSize(GetCurrentProcess(), &min_ws_size, &max_ws_size)) {
523		LLAMA_LOG_WARN("warning: GetProcessWorkingSetSize failed: %s\n",
524		llama_format_win_err(GetLastError()).c_str());
525		return false;
526		}
527		size_t increment = len + 1048576;
528		min_ws_size += increment;
529		max_ws_size += increment;
530		if (!SetProcessWorkingSetSize(GetCurrentProcess(), min_ws_size, max_ws_size)) {
531		LLAMA_LOG_WARN("warning: SetProcessWorkingSetSize failed: %s\n",
532		llama_format_win_err(GetLastError()).c_str());
533		return false;
534		}
535		}
536		}
537
538		static void raw_unlock(void * ptr, size_t len) {
539		if (!VirtualUnlock(ptr, len)) {
540		LLAMA_LOG_WARN("warning: failed to VirtualUnlock buffer: %s\n",
541		llama_format_win_err(GetLastError()).c_str());
542		}
543		}
544		#else
545		static size_t lock_granularity() {
546		return (size_t) 65536;
547		}
548
549		bool raw_lock(const void * addr, size_t len) const {
550		LLAMA_LOG_WARN("warning: mlock not supported on this system\n");
551		return false;
552		}
553
554		static void raw_unlock(const void * addr, size_t len) {}
555		#endif
556
557	0	impl() : addr(NULL), size(0), failed_already(false) {}
558
559	0	void init(void * ptr) {
560	0	GGML_ASSERT(addr == NULL && size == 0);
561	0	addr = ptr;
562	0	}
563
564	0	void grow_to(size_t target_size) {
565	0	GGML_ASSERT(addr);
566	0	if (failed_already) {
567	0	return;
568	0	}
569	0	size_t granularity = lock_granularity();
570	0	target_size = (target_size + granularity - 1) & ~(granularity - 1);
571	0	if (target_size > size) {
572	0	if (raw_lock((uint8_t *) addr + size, target_size - size)) {
573	0	size = target_size;
574	0	} else {
575	0	failed_already = true;
576	0	}
577	0	}
578	0	}
579
580		void * addr;
581		size_t size;
582
583		bool failed_already;
584		};
585
586	0	llama_mlock::llama_mlock() : pimpl(std::make_unique<impl>()) {}
587	0	llama_mlock::~llama_mlock() = default;
588
589	0	void llama_mlock::init(void * ptr) { pimpl->init(ptr); }
590	0	void llama_mlock::grow_to(size_t target_size) { pimpl->grow_to(target_size); }
591
592		#if defined(_POSIX_MEMLOCK_RANGE) \|\| defined(_WIN32)
593		const bool llama_mlock::SUPPORTED = true;
594		#else
595		const bool llama_mlock::SUPPORTED = false;
596		#endif
597
598	0	size_t llama_path_max() {
599		return PATH_MAX;
600	0	}