llama : introduce pread_raw and pwrite_raw

Author: cebtenzzre

llama.cpp

@@ -547,6 +547,36 @@ struct llama_file {
         }
     }
 
+    void pread_raw(void * ptr, size_t len, int64_t offset)  const {
+#ifndef _WIN32
+        int fd = fileno(fp);
+        ssize_t nread;
+        while (len) {
+            nread = pread(fd, ptr, len, off_t(offset));
+            if (nread < 0) {
+                throw std::runtime_error(format("read error: %s", strerror(errno)));
+            }
+            if (nread == 0) {
+                throw std::runtime_error("unexpectedly reached end of file");
+            }
+            len -= nread;
+            offset += nread;
+        }
+#else
+        if (len == 0) { return; }
+        HANDLE handle = (HANDLE)_get_osfhandle(_fileno(fp));
+        DWORD nread;
+        OVERLAPPED overlapped = {};
+        overlapped.Offset = DWORD(offset);
+        overlapped.OffsetHigh = DWORD(offset << 32);
+        bool res = ReadFile(handle, ptr, len, &nread, &overlapped);
+        if (!res) {
+            auto error = GetLastError();
+            throw std::runtime_error(format("ReadFile failed: %s", llama_format_win_err(error).c_str()));
+        }
+#endif
+    }
+
     uint32_t read_u32() const {
         uint32_t ret;
         read_raw(&ret, sizeof(ret));
@@ -564,6 +594,32 @@ struct llama_file {
         }
     }
 
+    void pwrite_raw(const void * ptr, size_t len, int64_t offset) const {
+#ifndef _WIN32
+        int fd = fileno(fp);
+        ssize_t nwrite;
+        while (len) {
+            nwrite = pwrite(fd, ptr, len, off_t(offset));
+            if (nwrite < 0) {
+                throw std::runtime_error(format("write error: %s", strerror(errno)));
+            }
+            len -= nwrite;
+            offset += nwrite;
+        }
+#else
+        auto * handle = (HANDLE)_get_osfhandle(_fileno(fp));
+        DWORD nwrite;
+        OVERLAPPED overlapped = {};
+        overlapped.Offset = DWORD(offset);
+        overlapped.OffsetHigh = DWORD(offset << 32);
+        bool res = WriteFile(handle, ptr, len, &nwrite, &overlapped);
+        if (!res) {
+            auto error = GetLastError();
+            throw std::runtime_error(format("WriteFile failed: %s", llama_format_win_err(error).c_str()));
+        }
+#endif
+    }
+
     void write_u32(std::uint32_t val) const {
         write_raw(&val, sizeof(val));
     }
@@ -1446,16 +1502,7 @@ struct llama_model_loader {
         if (use_mmap) {
             cur->data = (uint8_t *) mapping->addr + offs;
         } else {
-#ifndef _WIN32
-            pread(fileno(file.fp), cur->data, ggml_nbytes(cur), offs);
-#else
-            auto * handle = (HANDLE)_get_osfhandle(_fileno(file.fp));
-            DWORD nread;
-            OVERLAPPED overlapped = {};
-            overlapped.Offset = DWORD(offs);
-            overlapped.OffsetHigh = DWORD(offs << 32);
-            ReadFile(handle, cur->data, ggml_nbytes(cur), &nread, &overlapped);
-#endif
+            file.pread_raw(cur->data, ggml_nbytes(cur), offs);
         }
     }
 
@@ -4916,32 +4963,26 @@ static void llama_model_quantize_internal(const std::string & fname_inp, const s
         gguf_add_tensor(ctx_out, meta);
     }
 
-    auto * fout = fopen(fname_out.c_str(), "wb");
+    auto fout = llama_file(fname_out.c_str(), "wb");
 
     const size_t meta_size = gguf_get_meta_size(ctx_out);
 
     LLAMA_LOG_INFO("%s: meta size = %zu bytes\n", __func__, meta_size);
 
     // placeholder for the meta data
-    fseek(fout, meta_size, SEEK_SET);
+    fout.seek(meta_size, SEEK_SET);
 
     std::vector<std::vector<no_init<float>>> f32_conv_buf_pool(nthreads2);
     std::mutex log_mutex;
 
-#ifndef _WIN32
-    using off_type = off_t;
-#else
-    using off_type = LONGLONG;
-#endif
-
     std::vector<ggml_type> quant_tensor_types;
     std::vector<size_t>    quant_tensor_sizes;
-    std::vector<off_type>  quant_tensor_offsets;
+    std::vector<int64_t>   quant_tensor_offsets;
     quant_tensor_types.reserve(ml->n_tensors);
     quant_tensor_sizes.reserve(ml->n_tensors);
     quant_tensor_offsets.reserve(ml->n_tensors);
 
-    off_type fpos = meta_size;
+    int64_t fpos = meta_size;
     for (int i = 0; i < ml->n_tensors; ++i) {
         struct ggml_tensor * tensor = ml->get_tensor_meta(i);
 
@@ -5094,16 +5135,7 @@ static void llama_model_quantize_internal(const std::string & fname_inp, const s
         log_lock.unlock();
 
         // write tensor data
-#ifndef _WIN32
-        pwrite(fileno(fout), new_data, new_size, quant_tensor_offsets[i]);
-#else
-        auto* handle = (HANDLE)_get_osfhandle(_fileno(fout));
-        DWORD nwrite;
-        OVERLAPPED overlapped = {};
-        overlapped.Offset = DWORD(quant_tensor_offsets[i]);
-        overlapped.OffsetHigh = DWORD(quant_tensor_offsets[i] << 32);
-        WriteFile(handle, new_data, new_size, &nwrite, &overlapped);
-#endif
+        fout.pwrite_raw(new_data, new_size, quant_tensor_offsets[i]);
     };
 
     {
@@ -5115,18 +5147,16 @@ static void llama_model_quantize_internal(const std::string & fname_inp, const s
     }
 
     // write final padding
-    fseek(fout, fpos, SEEK_SET);
+    fout.seek(fpos, SEEK_SET);
 
     // go back to beginning of file and write the updated meta data
     {
-        rewind(fout);
+        fout.seek(0, SEEK_SET);
         std::vector<uint8_t> data(gguf_get_meta_size(ctx_out));
         gguf_get_meta_data(ctx_out, data.data());
-        fwrite(data.data(), data.size(), 1, fout);
+        fout.write_raw(data.data(), data.size());
     }
 
-    fclose(fout);
-
     gguf_free(ctx_out);
 
     LLAMA_LOG_INFO("%s: model size  = %8.2f MB\n", __func__, total_size_org/1024.0/1024.0);