[common] GGUF reader from memory

Add new GGUF reader implementation that can read metadata from a memory buffer.

Author: jesusmb1995

ggml/include/gguf.h

@@ -78,7 +78,6 @@ extern "C" {
 
     GGML_API struct gguf_context * gguf_init_empty(void);
     GGML_API struct gguf_context * gguf_init_from_file(const char * fname, struct gguf_init_params params);
-    //GGML_API struct gguf_context * gguf_init_from_buffer(..);
 
     GGML_API void gguf_free(struct gguf_context * ctx);
 
@@ -200,3 +199,8 @@ extern "C" {
 #ifdef  __cplusplus
 }
 #endif
+
+#ifdef __cplusplus
+#include <ios>
+GGML_API struct gguf_context * gguf_init_from_buffer(std::basic_streambuf<uint8_t>& streambuf, struct gguf_init_params params);
+#endif

ggml/src/gguf.cpp

@@ -2,6 +2,7 @@
 #include "ggml-backend.h"
 #include "ggml-impl.h"
 #include "gguf.h"
+#include "uint8-buff-stream.h"
 
 #include <cinttypes>
 #include <cstddef>
@@ -216,14 +217,79 @@ struct gguf_context {
     void * data = nullptr;
 };
 
-struct gguf_reader {
+struct gguf_bytes_reader {
+    /// @brief Reads up to `count` objects into the array `buffer`.
+    /// The position of the underlying stream implementation is advanced
+    /// by the number of characters read.
+    ///
+    /// @note If an error occurs, the resulting value of the underlying stream
+    /// position indicator is indeterminate.
+    virtual size_t read(void * buffer, size_t size, size_t count) = 0;
+
+    /// @brief Seeks to a position aligned to the given alignment boundary.
+    /// @return The current position after alignment, or 0 on error.
+    virtual size_t align(size_t alignment) = 0;
+
+    virtual ~gguf_bytes_reader() = 0;
+};
+
+gguf_bytes_reader::~gguf_bytes_reader() {}
+
+struct gguf_bytes_buffer_reader : public gguf_bytes_reader {
+    gguf_bytes_buffer_reader(std::basic_streambuf<uint8_t> & streambuf) : streambuf(streambuf), offset(0) {}
+
+    ~gguf_bytes_buffer_reader() {}
+
+    size_t read(void * buffer, size_t size, size_t count) override {
+        size_t total_size = size * count;
+        auto   bytes_read = streambuf.sgetn(static_cast<uint8_t *>(buffer), total_size);
+        offset += bytes_read;
+        return bytes_read;
+    }
+
+    size_t align(size_t alignment) override {
+        size_t new_offset  = GGML_PAD(offset, alignment);
+        size_t seek_offset = new_offset - offset;
+
+        auto result = streambuf.pubseekoff(seek_offset, std::ios_base::cur);
+        if (result == std::streampos(-1)) {
+            return 0;
+        }
+        offset = new_offset;
+        return offset;
+    }
+
+  private:
+    std::basic_streambuf<uint8_t> & streambuf;
+    size_t                          offset;
+};
+
+struct gguf_bytes_file_reader : public gguf_bytes_reader {
+    gguf_bytes_file_reader(FILE * file) : file(file) {}
+
+    ~gguf_bytes_file_reader() {}
+
+    size_t read(void * buffer, size_t size, size_t count) override { return fread(buffer, 1, size * count, file); }
+
+    size_t align(size_t alignment) override {
+        if (fseek(file, GGML_PAD(ftell(file), alignment), SEEK_SET) != 0) {
+            return 0;
+        }
+        return ftell(file);
+    }
+
+  private:
     FILE * file;
+};
 
-    gguf_reader(FILE * file) : file(file) {}
+struct gguf_reader {
+    gguf_bytes_reader& bytes_reader;
+
+    gguf_reader(gguf_bytes_reader& bytes_reader) : bytes_reader(bytes_reader) {}
 
     template <typename T>
     bool read(T & dst) const {
-        return fread(&dst, 1, sizeof(dst), file) == sizeof(dst);
+        return bytes_reader.read(&dst, 1, sizeof(dst)) == sizeof(dst);
     }
 
     template <typename T>
@@ -278,11 +344,11 @@ struct gguf_reader {
             return false;
         }
         dst.resize(size);
-        return fread(dst.data(), 1, dst.length(), file) == dst.length();
+        return bytes_reader.read(dst.data(), 1, dst.length()) == dst.length();
     }
 
     bool read(void * dst, const size_t size) const {
-        return fread(dst, 1, size, file) == size;
+        return bytes_reader.read(dst, 1, size) == size;
     }
 };
 
@@ -316,8 +382,8 @@ bool gguf_read_emplace_helper(const struct gguf_reader & gr, std::vector<struct
     return true;
 }
 
-struct gguf_context * gguf_init_from_file_impl(FILE * file, struct gguf_init_params params) {
-    const struct gguf_reader gr(file);
+namespace {
+struct gguf_context * gguf_init_from_reader_impl(const struct gguf_reader& gr, struct gguf_init_params params) {
     struct gguf_context * ctx = new gguf_context;
 
     bool ok = true;
@@ -606,15 +672,14 @@ struct gguf_context * gguf_init_from_file_impl(FILE * file, struct gguf_init_par
     GGML_ASSERT(int64_t(ctx->info.size()) == n_tensors);
 
     // we require the data section to be aligned, so take into account any padding
-    if (fseek(file, GGML_PAD(ftell(file), ctx->alignment), SEEK_SET) != 0) {
-        GGML_LOG_ERROR("%s: failed to seek to beginning of data section\n", __func__);
+    // store the current file offset - this is where the data section starts
+    ctx->offset = gr.bytes_reader.align(ctx->alignment);
+    if (ctx->offset == 0) {
+        GGML_LOG_ERROR("%s: failed to align data section\n", __func__);
         gguf_free(ctx);
         return nullptr;
     }
 
-    // store the current file offset - this is where the data section starts
-    ctx->offset = ftell(file);
-
     // compute the total size of the data section, taking into account the alignment
     {
         ctx->size = 0;
@@ -718,6 +783,13 @@ struct gguf_context * gguf_init_from_file_impl(FILE * file, struct gguf_init_par
 
     return ctx;
 }
+}
+
+struct gguf_context * gguf_init_from_file_impl(FILE * file, struct gguf_init_params params) {
+    gguf_bytes_file_reader bytes_reader(file);
+    gguf_reader            reader(bytes_reader);
+    return gguf_init_from_reader_impl(reader, params);
+}
 
 struct gguf_context * gguf_init_from_file(const char * fname, struct gguf_init_params params) {
     FILE * file = ggml_fopen(fname, "rb");
@@ -732,6 +804,12 @@ struct gguf_context * gguf_init_from_file(const char * fname, struct gguf_init_p
     return result;
 }
 
+struct gguf_context * gguf_init_from_buffer(std::basic_streambuf<uint8_t> & streambuf, struct gguf_init_params params) {
+    gguf_bytes_buffer_reader bytes_reader(streambuf);
+    gguf_reader              reader(bytes_reader);
+    return gguf_init_from_reader_impl(reader, params);
+}
+
 void gguf_free(struct gguf_context * ctx) {
     if (ctx == nullptr) {
         return;