struct ggml_tensor * const result = (struct ggml_tensor *)((char *)ctx->mem_buffer + obj_new->offs);
-#ifdef __clang__
- // temporary until ggml_tensor::backend is removed
- #pragma clang diagnostic push
- #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
*result = (struct ggml_tensor) {
/*.type =*/ type,
- /*.backend =*/ GGML_BACKEND_TYPE_CPU,
/*.buffer =*/ NULL,
/*.ne =*/ { 1, 1, 1, 1 },
/*.nb =*/ { 0, 0, 0, 0 },
/*.padding =*/ { 0 },
};
-#ifdef __clang__
- #pragma clang diagnostic pop
-#endif
-
// TODO: this should not be needed as long as we don't rely on aligned SIMD loads
//GGML_ASSERT_ALIGNED(result->data);
////////////////////////////////////////////////////////////////////////////////
-struct gguf_str {
- uint64_t n; // GGUFv2
- char * data;
-};
-
-static const size_t GGUF_TYPE_SIZE[GGUF_TYPE_COUNT] = {
- [GGUF_TYPE_UINT8] = sizeof(uint8_t),
- [GGUF_TYPE_INT8] = sizeof(int8_t),
- [GGUF_TYPE_UINT16] = sizeof(uint16_t),
- [GGUF_TYPE_INT16] = sizeof(int16_t),
- [GGUF_TYPE_UINT32] = sizeof(uint32_t),
- [GGUF_TYPE_INT32] = sizeof(int32_t),
- [GGUF_TYPE_FLOAT32] = sizeof(float),
- [GGUF_TYPE_BOOL] = sizeof(bool),
- [GGUF_TYPE_STRING] = sizeof(struct gguf_str),
- [GGUF_TYPE_UINT64] = sizeof(uint64_t),
- [GGUF_TYPE_INT64] = sizeof(int64_t),
- [GGUF_TYPE_FLOAT64] = sizeof(double),
- [GGUF_TYPE_ARRAY] = 0, // undefined
-};
-static_assert(GGUF_TYPE_COUNT == 13, "GGUF_TYPE_COUNT != 13");
-
-static const char * GGUF_TYPE_NAME[GGUF_TYPE_COUNT] = {
- [GGUF_TYPE_UINT8] = "u8",
- [GGUF_TYPE_INT8] = "i8",
- [GGUF_TYPE_UINT16] = "u16",
- [GGUF_TYPE_INT16] = "i16",
- [GGUF_TYPE_UINT32] = "u32",
- [GGUF_TYPE_INT32] = "i32",
- [GGUF_TYPE_FLOAT32] = "f32",
- [GGUF_TYPE_BOOL] = "bool",
- [GGUF_TYPE_STRING] = "str",
- [GGUF_TYPE_ARRAY] = "arr",
- [GGUF_TYPE_UINT64] = "u64",
- [GGUF_TYPE_INT64] = "i64",
- [GGUF_TYPE_FLOAT64] = "f64",
-};
-static_assert(GGUF_TYPE_COUNT == 13, "GGUF_TYPE_COUNT != 13");
-
-union gguf_value {
- uint8_t uint8;
- int8_t int8;
- uint16_t uint16;
- int16_t int16;
- uint32_t uint32;
- int32_t int32;
- float float32;
- uint64_t uint64;
- int64_t int64;
- double float64;
- bool bool_;
-
- struct gguf_str str;
-
- struct {
- enum gguf_type type;
-
- uint64_t n; // GGUFv2
- void * data;
- } arr;
-};
-
-struct gguf_kv {
- struct gguf_str key;
-
- enum gguf_type type;
- union gguf_value value;
-};
-
-struct gguf_header {
- char magic[4];
-
- uint32_t version;
- uint64_t n_tensors; // GGUFv2
- uint64_t n_kv; // GGUFv2
-};
-
-struct gguf_tensor_info {
- struct gguf_str name;
-
- uint32_t n_dims;
- uint64_t ne[GGML_MAX_DIMS];
-
- enum ggml_type type;
-
- uint64_t offset; // offset from start of `data`, must be a multiple of `ALIGNMENT`
-
- // for writing API
- const void * data;
- size_t size;
-};
-
-struct gguf_context {
- struct gguf_header header;
-
- struct gguf_kv * kv;
- struct gguf_tensor_info * infos;
-
- size_t alignment;
- size_t offset; // offset of `data` from beginning of file
- size_t size; // size of `data` in bytes
-
- //uint8_t * padding;
- void * data;
-};
-
-size_t gguf_type_size(enum gguf_type type) {
- GGML_ASSERT(0 <= type && type < GGUF_TYPE_COUNT);
- return GGUF_TYPE_SIZE[type];
-}
-
-static bool gguf_tensor_info_sanitize(struct gguf_tensor_info * info) {
- if (info->n_dims > GGML_MAX_DIMS) {
- fprintf(stderr, "%s: invalid number of dimensions (%" PRIu32 ")\n", __func__, info->n_dims);
- return false;
- }
-
- if (info->type < 0 || info->type >= GGML_TYPE_COUNT) {
- fprintf(stderr, "%s: invalid type (%d)\n", __func__, info->type);
- return false;
- }
-
- if (strlen(info->name.data) >= GGML_MAX_NAME) {
- fprintf(stderr, "%s: tensor '%s' name is too long\n", __func__, info->name.data);
- return false;
- }
-
- for (uint32_t i = 0; i < info->n_dims; ++i) {
- if (info->ne[i] <= 0) {
- fprintf(stderr, "%s: invalid number of elements (%" PRIu64 ")\n", __func__, info->ne[i]);
- return false;
- }
- }
-
- // prevent overflow for total number of elements
- if (INT64_MAX/info->ne[1] <= info->ne[0]) {
- fprintf(stderr, "%s: invalid number of elements (%" PRIu64 ")\n", __func__, info->ne[1]);
- return false;
- }
-
- if (INT64_MAX/info->ne[2] <= info->ne[0]*info->ne[1]) {
- fprintf(stderr, "%s: invalid number of elements (%" PRIu64 ")\n", __func__, info->ne[2]);
- return false;
- }
-
- if (INT64_MAX/info->ne[3] <= info->ne[0]*info->ne[1]*info->ne[2]) {
- fprintf(stderr, "%s: invalid number of elements (%" PRIu64 ")\n", __func__, info->ne[3]);
- return false;
- }
-
- return true;
-}
-
-static bool gguf_fread_el(FILE * file, void * dst, size_t size, size_t * offset) {
- const size_t n = fread(dst, 1, size, file);
- *offset += n;
- return n == size;
-}
-
-static bool gguf_fread_str(FILE * file, struct gguf_str * p, size_t * offset) {
- p->n = 0;
- p->data = NULL;
-
- bool ok = true;
-
- ok = ok && gguf_fread_el(file, &p->n, sizeof(p->n), offset);
-
- // early exit if string length is invalid, prevents from integer overflow
- if (p->n == SIZE_MAX) {
- fprintf(stderr, "%s: invalid string length (%" PRIu64 ")\n", __func__, p->n);
- return false;
- }
-
- p->data = calloc(p->n + 1, 1);
- if (!p->data) {
- fprintf(stderr, "%s: failed to allocate memory for string of length %" PRIu64 "\n", __func__, p->n);
- return false;
- }
-
- ok = ok && gguf_fread_el(file, p->data, p->n, offset);
-
- return ok;
-}
-
-static void gguf_free_kv(struct gguf_kv * kv) {
- if (kv->key.data) {
- GGML_FREE(kv->key.data);
- }
-
- if (kv->type == GGUF_TYPE_STRING) {
- if (kv->value.str.data) {
- GGML_FREE(kv->value.str.data);
- }
- }
-
- if (kv->type == GGUF_TYPE_ARRAY) {
- if (kv->value.arr.data) {
- if (kv->value.arr.type == GGUF_TYPE_STRING) {
- for (uint64_t j = 0; j < kv->value.arr.n; ++j) {
- struct gguf_str * str = &((struct gguf_str *) kv->value.arr.data)[j];
- if (str->data) {
- GGML_FREE(str->data);
- }
- }
- }
- GGML_FREE(kv->value.arr.data);
- }
- }
-}
-
-struct gguf_context * gguf_init_empty(void) {
- struct gguf_context * ctx = calloc(1, sizeof(struct gguf_context));
- if (!ctx) {
- fprintf(stderr, "%s: failed to allocate memory for context\n", __func__);
- return NULL;
- }
-
- memcpy(ctx->header.magic, GGUF_MAGIC, sizeof(ctx->header.magic));
- ctx->header.version = GGUF_VERSION;
- ctx->header.n_tensors = 0;
- ctx->header.n_kv = 0;
-
- ctx->kv = NULL;
- ctx->infos = NULL;
-
- ctx->alignment = GGUF_DEFAULT_ALIGNMENT;
- ctx->offset = 0;
- ctx->size = 0;
-
- ctx->data = NULL;
-
- return ctx;
-}
-
-struct gguf_context * gguf_init_from_file_impl(FILE * file, struct gguf_init_params params) {
- // offset from start of file
- size_t offset = 0;
-
- char magic[4];
-
- // check the magic before making allocations
- {
- gguf_fread_el(file, &magic, sizeof(magic), &offset);
-
- for (uint32_t i = 0; i < sizeof(magic); i++) {
- if (magic[i] != GGUF_MAGIC[i]) {
- fprintf(stderr, "%s: invalid magic characters '%c%c%c%c'\n", __func__, magic[0], magic[1], magic[2], magic[3]);
- return NULL;
- }
- }
- }
-
- bool ok = true;
-
- struct gguf_context * ctx = calloc(1, sizeof(struct gguf_context));
- if (!ctx) {
- fprintf(stderr, "%s: failed to allocate memory for context\n", __func__);
- return NULL;
- }
-
- // read the header
- {
- strncpy(ctx->header.magic, magic, 4);
-
- ctx->kv = NULL;
- ctx->infos = NULL;
- ctx->data = NULL;
-
- ok = ok && gguf_fread_el(file, &ctx->header.version, sizeof(ctx->header.version), &offset);
- ok = ok && gguf_fread_el(file, &ctx->header.n_tensors, sizeof(ctx->header.n_tensors), &offset);
- ok = ok && gguf_fread_el(file, &ctx->header.n_kv, sizeof(ctx->header.n_kv), &offset);
-
- if (ctx->header.version == 1) {
- fprintf(stderr, "%s: GGUFv1 is no longer supported. please use a more up-to-date version\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
-
- // sanity-checks to prevent from integer/buffer overflows
-
- ok = ok && (ctx->header.n_tensors < (SIZE_MAX/2)/sizeof(struct gguf_tensor_info));
- ok = ok && (ctx->header.n_tensors < (SIZE_MAX/2)/ggml_tensor_overhead());
- ok = ok && (ctx->header.n_kv < (SIZE_MAX/2)/sizeof(struct gguf_kv));
-
- if (!ok) {
- fprintf(stderr, "%s: failed to read header\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
- }
-
- // read the kv pairs
- {
- const uint64_t n_kv = ctx->header.n_kv;
-
- if (n_kv > 0) {
- ctx->kv = calloc(n_kv, sizeof(struct gguf_kv));
- if (!ctx->kv) {
- fprintf(stderr, "%s: failed to allocate memory for kv pairs\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
- }
-
- for (uint64_t i = 0; i < n_kv; ++i) {
- struct gguf_kv * kv = &ctx->kv[i];
-
- //fprintf(stderr, "%s: reading kv %d\n", __func__, i);
-
- ok = ok && gguf_fread_str(file, &kv->key, &offset);
- ok = ok && gguf_fread_el (file, &kv->type, sizeof(kv->type), &offset);
-
- //fprintf(stderr, "%s: reading kv with key %s\n", __func__, kv->key.data);
-
- switch (kv->type) {
- case GGUF_TYPE_UINT8: ok = ok && gguf_fread_el (file, &kv->value.uint8, sizeof(kv->value.uint8), &offset); break;
- case GGUF_TYPE_INT8: ok = ok && gguf_fread_el (file, &kv->value.int8, sizeof(kv->value.int8), &offset); break;
- case GGUF_TYPE_UINT16: ok = ok && gguf_fread_el (file, &kv->value.uint16, sizeof(kv->value.uint16), &offset); break;
- case GGUF_TYPE_INT16: ok = ok && gguf_fread_el (file, &kv->value.int16, sizeof(kv->value.int16), &offset); break;
- case GGUF_TYPE_UINT32: ok = ok && gguf_fread_el (file, &kv->value.uint32, sizeof(kv->value.uint32), &offset); break;
- case GGUF_TYPE_INT32: ok = ok && gguf_fread_el (file, &kv->value.int32, sizeof(kv->value.int32), &offset); break;
- case GGUF_TYPE_FLOAT32: ok = ok && gguf_fread_el (file, &kv->value.float32, sizeof(kv->value.float32), &offset); break;
- case GGUF_TYPE_UINT64: ok = ok && gguf_fread_el (file, &kv->value.uint64, sizeof(kv->value.uint64), &offset); break;
- case GGUF_TYPE_INT64: ok = ok && gguf_fread_el (file, &kv->value.int64, sizeof(kv->value.int64), &offset); break;
- case GGUF_TYPE_FLOAT64: ok = ok && gguf_fread_el (file, &kv->value.float64, sizeof(kv->value.float64), &offset); break;
- case GGUF_TYPE_BOOL: ok = ok && gguf_fread_el (file, &kv->value.bool_, sizeof(kv->value.bool_), &offset); break;
- case GGUF_TYPE_STRING: ok = ok && gguf_fread_str(file, &kv->value.str, &offset); break;
- case GGUF_TYPE_ARRAY:
- {
- ok = ok && gguf_fread_el(file, &kv->value.arr.type, sizeof(kv->value.arr.type), &offset);
- ok = ok && gguf_fread_el(file, &kv->value.arr.n, sizeof(kv->value.arr.n), &offset);
-
- switch (kv->value.arr.type) {
- case GGUF_TYPE_UINT8:
- case GGUF_TYPE_INT8:
- case GGUF_TYPE_UINT16:
- case GGUF_TYPE_INT16:
- case GGUF_TYPE_UINT32:
- case GGUF_TYPE_INT32:
- case GGUF_TYPE_FLOAT32:
- case GGUF_TYPE_UINT64:
- case GGUF_TYPE_INT64:
- case GGUF_TYPE_FLOAT64:
- case GGUF_TYPE_BOOL:
- {
- // prevent from integer overflow in the malloc below
- if (kv->value.arr.n >= SIZE_MAX/gguf_type_size(kv->value.arr.type)) {
- fprintf(stderr, "%s: array size is too large (%" PRIu64 ")\n", __func__, kv->value.arr.n);
- gguf_free(ctx);
- return NULL;
- }
-
- kv->value.arr.data = calloc(kv->value.arr.n, gguf_type_size(kv->value.arr.type));
- if (!kv->value.arr.data) {
- fprintf(stderr, "%s: failed to allocate memory for array\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
-
- ok = ok && gguf_fread_el(file, kv->value.arr.data, kv->value.arr.n * gguf_type_size(kv->value.arr.type), &offset);
- } break;
- case GGUF_TYPE_STRING:
- {
- // prevent from integer overflow in the malloc below
- if (kv->value.arr.n >= SIZE_MAX/sizeof(struct gguf_str)) {
- fprintf(stderr, "%s: array size is too large (%" PRIu64 ")\n", __func__, kv->value.arr.n);
- gguf_free(ctx);
- return NULL;
- }
-
- kv->value.arr.data = calloc(kv->value.arr.n, sizeof(struct gguf_str));
- if (!kv->value.arr.data) {
- fprintf(stderr, "%s: failed to allocate memory for array\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
-
- for (uint64_t j = 0; j < kv->value.arr.n; ++j) {
- ok = ok && gguf_fread_str(file, &((struct gguf_str *) kv->value.arr.data)[j], &offset);
- }
- } break;
- case GGUF_TYPE_ARRAY:
- default:
- {
- fprintf(stderr, "%s: invalid array type %d\n", __func__, kv->value.arr.type);
- ok = false;
- } break;
- }
- } break;
- default:
- {
- fprintf(stderr, "%s: invalid type %d\n", __func__, kv->type);
- ok = false;
- } break;
- }
-
- if (!ok) {
- break;
- }
- }
-
- if (!ok) {
- fprintf(stderr, "%s: failed to read key-value pairs\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
- }
-
- // read the tensor infos
- if (ctx->header.n_tensors > 0) {
- ctx->infos = calloc(ctx->header.n_tensors, sizeof(struct gguf_tensor_info));
- if (!ctx->infos) {
- fprintf(stderr, "%s: failed to allocate memory for tensor infos\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
-
- for (uint64_t i = 0; i < ctx->header.n_tensors; ++i) {
- struct gguf_tensor_info * info = &ctx->infos[i];
-
- for (int j = 0; j < GGML_MAX_DIMS; ++j) {
- info->ne[j] = 1;
- }
-
- ok = ok && gguf_fread_str(file, &info->name, &offset);
- ok = ok && gguf_fread_el (file, &info->n_dims, sizeof(info->n_dims), &offset);
-
- ok = ok && (info->n_dims <= GGML_MAX_DIMS);
-
- for (uint32_t j = 0; j < info->n_dims; ++j) {
- ok = ok && gguf_fread_el(file, &info->ne[j], sizeof(info->ne[j]), &offset);
- }
-
- ok = ok && gguf_fread_el (file, &info->type, sizeof(info->type), &offset);
- ok = ok && gguf_fread_el (file, &info->offset, sizeof(info->offset), &offset);
-
- ok = ok && gguf_tensor_info_sanitize(info);
-
- // make sure there is no duplicated tensor names
- for (uint64_t j = 0; j < i && ok; ++j) {
- if (strcmp(info->name.data, ctx->infos[j].name.data) == 0) {
- fprintf(stderr, "%s: duplicated tensor name %s\n", __func__, info->name.data);
- ok = false;
- }
- }
-
- if (!ok) {
- fprintf(stderr, "%s: failed to read tensor info\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
- }
- }
-
- ctx->alignment = GGUF_DEFAULT_ALIGNMENT;
-
- int alignment_idx = gguf_find_key(ctx, "general.alignment");
- if (alignment_idx != -1) {
- ctx->alignment = gguf_get_val_u32(ctx, alignment_idx);
- }
-
- // we require the data section to be aligned, so take into account any padding
- {
- const size_t offset_pad = offset % ctx->alignment;
-
- if (offset_pad != 0) {
- offset += ctx->alignment - offset_pad;
- fseek(file, offset, SEEK_SET);
- }
- }
-
- // store the current file offset - this is where the data section starts
- ctx->offset = offset;
-
- // compute the total size of the data section, taking into account the alignment
- {
- ctx->size = 0;
- for (uint64_t i = 0; i < ctx->header.n_tensors; ++i) {
- struct gguf_tensor_info * info = &ctx->infos[i];
-
- const int64_t ne =
- (int64_t) info->ne[0] *
- (int64_t) info->ne[1] *
- (int64_t) info->ne[2] *
- (int64_t) info->ne[3];
-
- if (ggml_blck_size(info->type) == 0 ) {
- // this tensor type support have been removed:
- fprintf(stderr, "%s: tensor '%s' of type %d: %s\n",
- __func__, info->name.data, (int) info->type, ggml_type_name(info->type));
- gguf_free(ctx);
- return NULL;
- }
-
- if (ne % ggml_blck_size(info->type) != 0) {
- fprintf(stderr, "%s: tensor '%s' of type %d (%s) number of elements (%" PRId64 ") is not a multiple of block size (%" PRId64 ")\n",
- __func__, info->name.data, (int) info->type, ggml_type_name(info->type), ne, ggml_blck_size(info->type));
- gguf_free(ctx);
- return NULL;
- }
-
- const size_t size_cur = ggml_row_size(info->type, ne);
-
- ctx->size += GGML_PAD(size_cur, ctx->alignment);
- }
- }
-
- // load the tensor data only if requested
- if (params.ctx != NULL) {
- // if the provided gguf_context is no_alloc, then we create "empty" tensors and do not read the binary blob
- // otherwise, we load the binary blob into the created ggml_context as well, and point the "data" members of
- // the ggml_tensor structs to the appropriate locations in the binary blob
-
- // compute the exact size needed for the new ggml_context
- const size_t mem_size =
- params.no_alloc ?
- (ctx->header.n_tensors )*ggml_tensor_overhead() :
- (ctx->header.n_tensors + 1)*ggml_tensor_overhead() + ctx->size;
-
- struct ggml_init_params pdata = {
- .mem_size = mem_size,
- .mem_buffer = NULL,
- .no_alloc = params.no_alloc,
- };
-
- *params.ctx = ggml_init(pdata);
- if (*params.ctx == NULL) {
- fprintf(stderr, "%s: failed to initialize context\n", __func__);
- gguf_free(ctx);
- return NULL;
- }
-
- struct ggml_context * ctx_data = *params.ctx;
-
- struct ggml_tensor * data = NULL;
-
- if (!params.no_alloc) {
- data = ggml_new_tensor_1d(ctx_data, GGML_TYPE_I8, ctx->size);
-
- ok = ok && data != NULL;
-
- // read the binary blob with the tensor data
- ok = ok && gguf_fread_el(file, data->data, ctx->size, &offset);
-
- if (!ok) {
- fprintf(stderr, "%s: failed to read tensor data\n", __func__);
- ggml_free(ctx_data);
- gguf_free(ctx);
- return NULL;
- }
-
- ctx->data = data->data;
- }
-
- ggml_set_no_alloc(ctx_data, true);
-
- // create the tensors
- for (uint64_t i = 0; i < ctx->header.n_tensors; ++i) {
- const int64_t ne[GGML_MAX_DIMS] = {
- ctx->infos[i].ne[0],
- ctx->infos[i].ne[1],
- ctx->infos[i].ne[2],
- ctx->infos[i].ne[3],
- };
-
- struct ggml_tensor * cur = ggml_new_tensor(ctx_data, ctx->infos[i].type, ctx->infos[i].n_dims, ne);
-
- ok = ok && cur != NULL;
-
- if (!ok) {
- break;
- }
-
- ggml_set_name(cur, ctx->infos[i].name.data);
-
- // point the data member to the appropriate location in the binary blob using the tensor infos
- if (!params.no_alloc) {
- //cur->data = (char *) data->data + ctx->infos[i].offset - ctx->offset; // offset from start of file
- cur->data = (char *) data->data + ctx->infos[i].offset; // offset from data
- }
- }
-
- if (!ok) {
- fprintf(stderr, "%s: failed to read the tensor data\n", __func__);
- ggml_free(ctx_data);
- gguf_free(ctx);
- return NULL;
- }
-
- ggml_set_no_alloc(ctx_data, params.no_alloc);
- }
-
- return ctx;
-}
-
-struct gguf_context * gguf_init_from_file(const char * fname, struct gguf_init_params params) {
- FILE * file = ggml_fopen(fname, "rb");
- if (!file) {
- fprintf(stderr, "%s: failed to open '%s': '%s'\n", __func__, fname, strerror(errno));
- return NULL;
- }
-
- struct gguf_context * result = gguf_init_from_file_impl(file, params);
- fclose(file);
- return result;
-}
-
-void gguf_free(struct gguf_context * ctx) {
- if (ctx == NULL) {
- return;
- }
-
- if (ctx->kv) {
- // free string memory - not great..
- for (uint64_t i = 0; i < ctx->header.n_kv; ++i) {
- gguf_free_kv(&ctx->kv[i]);
- }
-
- GGML_FREE(ctx->kv);
- }
-
- if (ctx->infos) {
- for (uint64_t i = 0; i < ctx->header.n_tensors; ++i) {
- struct gguf_tensor_info * info = &ctx->infos[i];
-
- if (info->name.data) {
- GGML_FREE(info->name.data);
- }
- }
-
- GGML_FREE(ctx->infos);
- }
-
- GGML_FREE(ctx);
-}
-
-const char * gguf_type_name(enum gguf_type type) {
- return GGUF_TYPE_NAME[type];
-}
-
-int gguf_get_version(const struct gguf_context * ctx) {
- return ctx->header.version;
-}
-
-size_t gguf_get_alignment(const struct gguf_context * ctx) {
- return ctx->alignment;
-}
-
-size_t gguf_get_data_offset(const struct gguf_context * ctx) {
- return ctx->offset;
-}
-
-void * gguf_get_data(const struct gguf_context * ctx) {
- return ctx->data;
-}
-
-int gguf_get_n_kv(const struct gguf_context * ctx) {
- return ctx->header.n_kv;
-}
-
-int gguf_find_key(const struct gguf_context * ctx, const char * key) {
- // return -1 if key not found
- int keyfound = -1;
-
- const int n_kv = gguf_get_n_kv(ctx);
-
- for (int i = 0; i < n_kv; ++i) {
- if (strcmp(key, gguf_get_key(ctx, i)) == 0) {
- keyfound = i;
- break;
- }
- }
-
- return keyfound;
-}
-
-const char * gguf_get_key(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- return ctx->kv[key_id].key.data;
-}
-
-enum gguf_type gguf_get_kv_type(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- return ctx->kv[key_id].type;
-}
-
-enum gguf_type gguf_get_arr_type(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_ARRAY);
- return ctx->kv[key_id].value.arr.type;
-}
-
-const void * gguf_get_arr_data(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_ARRAY);
- return ctx->kv[key_id].value.arr.data;
-}
-
-const char * gguf_get_arr_str(const struct gguf_context * ctx, int key_id, int i) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_ARRAY);
- struct gguf_kv * kv = &ctx->kv[key_id];
- struct gguf_str * str = &((struct gguf_str *) kv->value.arr.data)[i];
- return str->data;
-}
-
-int gguf_get_arr_n(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_ARRAY);
- return ctx->kv[key_id].value.arr.n;
-}
-
-uint8_t gguf_get_val_u8(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_UINT8);
- return ctx->kv[key_id].value.uint8;
-}
-
-int8_t gguf_get_val_i8(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_INT8);
- return ctx->kv[key_id].value.int8;
-}
-
-uint16_t gguf_get_val_u16(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_UINT16);
- return ctx->kv[key_id].value.uint16;
-}
-
-int16_t gguf_get_val_i16(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_INT16);
- return ctx->kv[key_id].value.int16;
-}
-
-uint32_t gguf_get_val_u32(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_UINT32);
- return ctx->kv[key_id].value.uint32;
-}
-
-int32_t gguf_get_val_i32(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_INT32);
- return ctx->kv[key_id].value.int32;
-}
-
-float gguf_get_val_f32(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_FLOAT32);
- return ctx->kv[key_id].value.float32;
-}
-
-uint64_t gguf_get_val_u64(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_UINT64);
- return ctx->kv[key_id].value.uint64;
-}
-
-int64_t gguf_get_val_i64(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_INT64);
- return ctx->kv[key_id].value.int64;
-}
-
-double gguf_get_val_f64(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_FLOAT64);
- return ctx->kv[key_id].value.float64;
-}
-
-bool gguf_get_val_bool(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_BOOL);
- return ctx->kv[key_id].value.bool_;
-}
-
-const char * gguf_get_val_str(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type == GGUF_TYPE_STRING);
- return ctx->kv[key_id].value.str.data;
-}
-
-const void * gguf_get_val_data(const struct gguf_context * ctx, int key_id) {
- GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
- GGML_ASSERT(ctx->kv[key_id].type != GGUF_TYPE_ARRAY);
- GGML_ASSERT(ctx->kv[key_id].type != GGUF_TYPE_STRING);
- return &ctx->kv[key_id].value;
-}
-
-int gguf_get_n_tensors(const struct gguf_context * ctx) {
- return ctx->header.n_tensors;
-}
-
-int gguf_find_tensor(const struct gguf_context * ctx, const char * name) {
- // return -1 if tensor not found
- int tensorfound = -1;
-
- const int n_tensors = gguf_get_n_tensors(ctx);
-
- for (int i = 0; i < n_tensors; ++i) {
- if (strcmp(name, gguf_get_tensor_name(ctx, i)) == 0) {
- tensorfound = i;
- break;
- }
- }
-
- return tensorfound;
-}
-
-size_t gguf_get_tensor_offset(const struct gguf_context * ctx, int i) {
- return ctx->infos[i].offset;
-}
-
-char * gguf_get_tensor_name(const struct gguf_context * ctx, int i) {
- return ctx->infos[i].name.data;
-}
-
-enum ggml_type gguf_get_tensor_type(const struct gguf_context * ctx, int i) {
- return ctx->infos[i].type;
-}
-
-// returns the index
-static int gguf_get_or_add_key(struct gguf_context * ctx, const char * key) {
- const int idx = gguf_find_key(ctx, key);
- if (idx >= 0) {
- return idx;
- }
-
- const int n_kv = gguf_get_n_kv(ctx);
-
- ctx->kv = realloc(ctx->kv, (n_kv + 1) * sizeof(struct gguf_kv));
- ctx->kv[n_kv].key.n = strlen(key);
- ctx->kv[n_kv].key.data = strdup(key);
- ctx->header.n_kv++;
-
- return n_kv;
-}
-
-void gguf_remove_key(struct gguf_context * ctx, const char * key) {
- const int idx = gguf_find_key(ctx, key);
- if (idx >= 0) {
- const int n_kv = gguf_get_n_kv(ctx);
- gguf_free_kv(&ctx->kv[idx]);
- for (int i = idx; i < n_kv-1; ++i) {
- ctx->kv[i] = ctx->kv[i+1];
- }
- ctx->kv = realloc(ctx->kv, (n_kv - 1) * sizeof(struct gguf_kv));
- ctx->header.n_kv--;
- }
-}
-
-void gguf_set_val_u8(struct gguf_context * ctx, const char * key, uint8_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_UINT8;
- ctx->kv[idx].value.uint8 = val;
-}
-
-void gguf_set_val_i8(struct gguf_context * ctx, const char * key, int8_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_INT8;
- ctx->kv[idx].value.int8 = val;
-}
-
-void gguf_set_val_u16(struct gguf_context * ctx, const char * key, uint16_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_UINT16;
- ctx->kv[idx].value.uint16 = val;
-}
-
-void gguf_set_val_i16(struct gguf_context * ctx, const char * key, int16_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_INT16;
- ctx->kv[idx].value.int16 = val;
-}
-
-void gguf_set_val_u32(struct gguf_context * ctx, const char * key, uint32_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_UINT32;
- ctx->kv[idx].value.uint32 = val;
-}
-
-void gguf_set_val_i32(struct gguf_context * ctx, const char * key, int32_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_INT32;
- ctx->kv[idx].value.int32 = val;
-}
-
-void gguf_set_val_f32(struct gguf_context * ctx, const char * key, float val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_FLOAT32;
- ctx->kv[idx].value.float32 = val;
-}
-
-void gguf_set_val_u64(struct gguf_context * ctx, const char * key, uint64_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_UINT64;
- ctx->kv[idx].value.uint64 = val;
-}
-
-void gguf_set_val_i64(struct gguf_context * ctx, const char * key, int64_t val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_INT64;
- ctx->kv[idx].value.int64 = val;
-}
-
-void gguf_set_val_f64(struct gguf_context * ctx, const char * key, double val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_FLOAT64;
- ctx->kv[idx].value.float64 = val;
-}
-
-void gguf_set_val_bool(struct gguf_context * ctx, const char * key, bool val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_BOOL;
- ctx->kv[idx].value.bool_ = val;
-}
-
-void gguf_set_val_str(struct gguf_context * ctx, const char * key, const char * val) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_STRING;
- ctx->kv[idx].value.str.n = strlen(val);
- ctx->kv[idx].value.str.data = strdup(val);
-}
-
-void gguf_set_arr_data(struct gguf_context * ctx, const char * key, enum gguf_type type, const void * data, int n) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_ARRAY;
- ctx->kv[idx].value.arr.type = type;
- ctx->kv[idx].value.arr.n = n;
- ctx->kv[idx].value.arr.data = GGML_CALLOC(n, gguf_type_size(type));
- memcpy(ctx->kv[idx].value.arr.data, data, n*gguf_type_size(type));
-}
-
-void gguf_set_arr_str(struct gguf_context * ctx, const char * key, const char ** data, int n) {
- const int idx = gguf_get_or_add_key(ctx, key);
-
- ctx->kv[idx].type = GGUF_TYPE_ARRAY;
- ctx->kv[idx].value.arr.type = GGUF_TYPE_STRING;
- ctx->kv[idx].value.arr.n = n;
- ctx->kv[idx].value.arr.data = GGML_CALLOC(n, sizeof(struct gguf_str));
- for (int i = 0; i < n; i++) {
- struct gguf_str * str = &((struct gguf_str *)ctx->kv[idx].value.arr.data)[i];
- str->n = strlen(data[i]);
- str->data = strdup(data[i]);
- }
-}
-
-// set or add KV pairs from another context
-void gguf_set_kv(struct gguf_context * ctx, struct gguf_context * src) {
- for (uint32_t i = 0; i < src->header.n_kv; i++) {
- switch (src->kv[i].type) {
- case GGUF_TYPE_UINT8: gguf_set_val_u8 (ctx, src->kv[i].key.data, src->kv[i].value.uint8); break;
- case GGUF_TYPE_INT8: gguf_set_val_i8 (ctx, src->kv[i].key.data, src->kv[i].value.int8); break;
- case GGUF_TYPE_UINT16: gguf_set_val_u16 (ctx, src->kv[i].key.data, src->kv[i].value.uint16); break;
- case GGUF_TYPE_INT16: gguf_set_val_i16 (ctx, src->kv[i].key.data, src->kv[i].value.int16); break;
- case GGUF_TYPE_UINT32: gguf_set_val_u32 (ctx, src->kv[i].key.data, src->kv[i].value.uint32); break;
- case GGUF_TYPE_INT32: gguf_set_val_i32 (ctx, src->kv[i].key.data, src->kv[i].value.int32); break;
- case GGUF_TYPE_FLOAT32: gguf_set_val_f32 (ctx, src->kv[i].key.data, src->kv[i].value.float32); break;
- case GGUF_TYPE_UINT64: gguf_set_val_u64 (ctx, src->kv[i].key.data, src->kv[i].value.uint64); break;
- case GGUF_TYPE_INT64: gguf_set_val_i64 (ctx, src->kv[i].key.data, src->kv[i].value.int64); break;
- case GGUF_TYPE_FLOAT64: gguf_set_val_f64 (ctx, src->kv[i].key.data, src->kv[i].value.float64); break;
- case GGUF_TYPE_BOOL: gguf_set_val_bool(ctx, src->kv[i].key.data, src->kv[i].value.bool_); break;
- case GGUF_TYPE_STRING: gguf_set_val_str (ctx, src->kv[i].key.data, src->kv[i].value.str.data); break;
- case GGUF_TYPE_ARRAY:
- {
- if (src->kv[i].value.arr.type == GGUF_TYPE_STRING) {
- const char ** data = GGML_CALLOC(src->kv[i].value.arr.n, sizeof(char *));
- for (uint32_t j = 0; j < src->kv[i].value.arr.n; j++) {
- data[j] = ((struct gguf_str *)src->kv[i].value.arr.data)[j].data;
- }
- gguf_set_arr_str(ctx, src->kv[i].key.data, data, src->kv[i].value.arr.n);
- GGML_FREE((void *)data);
- } else if (src->kv[i].value.arr.type == GGUF_TYPE_ARRAY) {
- GGML_ABORT("nested arrays not supported");
- } else {
- gguf_set_arr_data(ctx, src->kv[i].key.data, src->kv[i].value.arr.type, src->kv[i].value.arr.data, src->kv[i].value.arr.n);
- }
- } break;
- default: GGML_ABORT("invalid type");
- }
- }
-}
-
-void gguf_add_tensor(
- struct gguf_context * ctx,
- const struct ggml_tensor * tensor) {
- GGML_ASSERT(tensor);
- if (gguf_find_tensor(ctx, tensor->name) != -1) {
- GGML_ABORT("duplicated tensor name");
- }
-
- const int idx = ctx->header.n_tensors;
- ctx->infos = realloc(ctx->infos, (idx + 1)*sizeof(struct gguf_tensor_info));
-
- ctx->infos[idx].name.n = strlen(tensor->name);
- ctx->infos[idx].name.data = strdup(tensor->name);
-
- for (int i = 0; i < GGML_MAX_DIMS; ++i) {
- ctx->infos[idx].ne[i] = 1;
- }
-
- ctx->infos[idx].n_dims = ggml_n_dims(tensor);
- for (uint32_t i = 0; i < ctx->infos[idx].n_dims; i++) {
- ctx->infos[idx].ne[i] = tensor->ne[i];
- }
-
- ctx->infos[idx].type = tensor->type;
- ctx->infos[idx].offset = 0;
- ctx->infos[idx].data = tensor->data;
- ctx->infos[idx].size = ggml_nbytes(tensor);
-
- if (ctx->header.n_tensors > 0) {
- ctx->infos[idx].offset = ctx->infos[idx - 1].offset + GGML_PAD(ctx->infos[idx - 1].size, ctx->alignment);
- }
-
- ctx->header.n_tensors++;
-}
-
-void gguf_set_tensor_type(struct gguf_context * ctx, const char * name, enum ggml_type type) {
- const int idx = gguf_find_tensor(ctx, name);
- if (idx < 0) {
- GGML_ABORT("tensor not found");
- }
-
- ctx->infos[idx].type = type;
-}
-
-void gguf_set_tensor_data(struct gguf_context * ctx, const char * name, const void * data, size_t size) {
- const int idx = gguf_find_tensor(ctx, name);
- if (idx < 0) {
- GGML_ABORT("tensor not found");
- }
-
- ctx->infos[idx].data = data;
- ctx->infos[idx].size = size;
-
- // update offsets
- for (uint32_t i = idx + 1; i < ctx->header.n_tensors; ++i) {
- ctx->infos[i].offset = ctx->infos[i - 1].offset + GGML_PAD(ctx->infos[i - 1].size, ctx->alignment);
- }
-}
-
-//static void gguf_fwrite_str(FILE * file, const struct gguf_str * val) {
-// fwrite(&val->n, sizeof(val->n), 1, file);
-// fwrite(val->data, sizeof(char), val->n, file);
-//}
-//
-//static void gguf_fwrite_el(FILE * file, const void * val, size_t size) {
-// fwrite(val, sizeof(char), size, file);
-//}
-
-struct gguf_buf gguf_buf_init(size_t size) {
- struct gguf_buf buf = {
- /*buf.data =*/ size == 0 ? NULL : GGML_CALLOC(1, size),
- /*buf.size =*/ size,
- /*buf.offset =*/ 0,
- };
-
- return buf;
-}
-
-void gguf_buf_free(struct gguf_buf buf) {
- if (buf.data) {
- GGML_FREE(buf.data);
- }
-}
-
-static void gguf_buf_grow(struct gguf_buf * buf, size_t size) {
- if (buf->offset + size > buf->size) {
- buf->size = 1.5*(buf->offset + size);
- if (buf->data) {
- buf->data = realloc(buf->data, buf->size);
- }
- }
-}
-
-static void gguf_bwrite_str(struct gguf_buf * buf, const struct gguf_str * val) {
- gguf_buf_grow(buf, sizeof(val->n) + val->n);
-
- if (buf->data) {
- memcpy((char *) buf->data + buf->offset, &val->n, sizeof(val->n));
- }
- buf->offset += sizeof(val->n);
-
- if (buf->data) {
- memcpy((char *) buf->data + buf->offset, val->data, val->n);
- }
- buf->offset += val->n;
-}
-
-static void gguf_bwrite_el(struct gguf_buf * buf, const void * val, size_t el_size) {
- gguf_buf_grow(buf, el_size);
-
- if (buf->data) {
- memcpy((char *) buf->data + buf->offset, val, el_size);
- }
- buf->offset += el_size;
-}
-
-void gguf_write_to_buf(const struct gguf_context * ctx, struct gguf_buf * buf, bool only_meta) {
- // write header
- gguf_bwrite_el(buf, &ctx->header.magic, sizeof(ctx->header.magic));
- gguf_bwrite_el(buf, &ctx->header.version, sizeof(ctx->header.version));
- gguf_bwrite_el(buf, &ctx->header.n_tensors, sizeof(ctx->header.n_tensors));
- gguf_bwrite_el(buf, &ctx->header.n_kv, sizeof(ctx->header.n_kv));
-
- // write key-value pairs
- for (uint32_t i = 0; i < ctx->header.n_kv; ++i) {
- struct gguf_kv * kv = &ctx->kv[i];
-
- gguf_bwrite_str(buf, &kv->key);
- gguf_bwrite_el (buf, &kv->type, sizeof(kv->type));
-
- switch (kv->type) {
- case GGUF_TYPE_UINT8: gguf_bwrite_el( buf, &kv->value.uint8, sizeof(kv->value.uint8) ); break;
- case GGUF_TYPE_INT8: gguf_bwrite_el (buf, &kv->value.int8, sizeof(kv->value.int8) ); break;
- case GGUF_TYPE_UINT16: gguf_bwrite_el (buf, &kv->value.uint16, sizeof(kv->value.uint16) ); break;
- case GGUF_TYPE_INT16: gguf_bwrite_el (buf, &kv->value.int16, sizeof(kv->value.int16) ); break;
- case GGUF_TYPE_UINT32: gguf_bwrite_el (buf, &kv->value.uint32, sizeof(kv->value.uint32) ); break;
- case GGUF_TYPE_INT32: gguf_bwrite_el (buf, &kv->value.int32, sizeof(kv->value.int32) ); break;
- case GGUF_TYPE_FLOAT32: gguf_bwrite_el (buf, &kv->value.float32, sizeof(kv->value.float32)); break;
- case GGUF_TYPE_UINT64: gguf_bwrite_el (buf, &kv->value.uint64, sizeof(kv->value.uint64) ); break;
- case GGUF_TYPE_INT64: gguf_bwrite_el (buf, &kv->value.int64, sizeof(kv->value.int64) ); break;
- case GGUF_TYPE_FLOAT64: gguf_bwrite_el (buf, &kv->value.float64, sizeof(kv->value.float64)); break;
- case GGUF_TYPE_BOOL: gguf_bwrite_el (buf, &kv->value.bool_, sizeof(kv->value.bool_) ); break;
- case GGUF_TYPE_STRING: gguf_bwrite_str(buf, &kv->value.str ); break;
- case GGUF_TYPE_ARRAY:
- {
- gguf_bwrite_el(buf, &kv->value.arr.type, sizeof(kv->value.arr.type));
- gguf_bwrite_el(buf, &kv->value.arr.n, sizeof(kv->value.arr.n) );
-
- switch (kv->value.arr.type) {
- case GGUF_TYPE_UINT8:
- case GGUF_TYPE_INT8:
- case GGUF_TYPE_UINT16:
- case GGUF_TYPE_INT16:
- case GGUF_TYPE_UINT32:
- case GGUF_TYPE_INT32:
- case GGUF_TYPE_FLOAT32:
- case GGUF_TYPE_UINT64:
- case GGUF_TYPE_INT64:
- case GGUF_TYPE_FLOAT64:
- case GGUF_TYPE_BOOL:
- {
- gguf_bwrite_el(buf, kv->value.arr.data, kv->value.arr.n * gguf_type_size(kv->value.arr.type));
- } break;
- case GGUF_TYPE_STRING:
- {
- for (uint32_t j = 0; j < kv->value.arr.n; ++j) {
- gguf_bwrite_str(buf, &((struct gguf_str *) kv->value.arr.data)[j]);
- }
- } break;
- case GGUF_TYPE_ARRAY:
- default: GGML_ABORT("invalid type");
- }
- } break;
- default: GGML_ABORT("invalid type");
- }
- }
-
- // write tensor infos
- for (uint32_t i = 0; i < ctx->header.n_tensors; ++i) {
- struct gguf_tensor_info * info = &ctx->infos[i];
-
- gguf_bwrite_str(buf, &info->name);
- gguf_bwrite_el (buf, &info->n_dims, sizeof(info->n_dims));
- for (uint32_t j = 0; j < info->n_dims; ++j) {
- gguf_bwrite_el(buf, &info->ne[j], sizeof(info->ne[j]));
- }
- gguf_bwrite_el(buf, &info->type, sizeof(info->type));
- gguf_bwrite_el(buf, &info->offset, sizeof(info->offset));
- }
-
- // we require the data section to be aligned, so take into account any padding
- {
- const size_t offset = buf->offset;
- const size_t offset_pad = GGML_PAD(offset, ctx->alignment);
-
- if (offset_pad != offset) {
- uint8_t pad = 0;
- for (size_t i = 0; i < offset_pad - offset; ++i) {
- gguf_bwrite_el(buf, &pad, sizeof(pad));
- }
- }
- }
-
- if (only_meta) {
- return;
- }
-
- size_t offset = 0;
-
- // write tensor data
- for (uint32_t i = 0; i < ctx->header.n_tensors; ++i) {
- struct gguf_tensor_info * info = &ctx->infos[i];
-
- const size_t size = info->size;
- const size_t size_pad = GGML_PAD(size, ctx->alignment);
-
- gguf_bwrite_el(buf, info->data, size);
-
- if (size_pad != size) {
- uint8_t pad = 0;
- for (size_t j = 0; j < size_pad - size; ++j) {
- gguf_bwrite_el(buf, &pad, sizeof(pad));
- }
- }
-
- GGML_ASSERT(offset == info->offset);
-
- offset += size_pad;
- }
-}
-
-void gguf_write_to_file(const struct gguf_context * ctx, const char * fname, bool only_meta) {
- FILE * file = ggml_fopen(fname, "wb");
- if (!file) {
- GGML_ABORT("failed to open file for writing");
- }
-
- struct gguf_buf buf = gguf_buf_init(16*1024);
-
- gguf_write_to_buf(ctx, &buf, only_meta);
-
- fwrite(buf.data, 1, buf.offset, file);
-
- gguf_buf_free(buf);
-
- fclose(file);
-}
-
-size_t gguf_get_meta_size(const struct gguf_context * ctx) {
- // no allocs - only compute size
- struct gguf_buf buf = gguf_buf_init(0);
-
- gguf_write_to_buf(ctx, &buf, true);
-
- return buf.offset;
-}
-
-void gguf_get_meta_data(const struct gguf_context * ctx, void * data) {
- struct gguf_buf buf = gguf_buf_init(16*1024);
-
- gguf_write_to_buf(ctx, &buf, true);
-
- memcpy(data, buf.data, buf.offset);
-
- gguf_buf_free(buf);
-}
-
void ggml_log_set(ggml_log_callback log_callback, void * user_data) {
g_logger_state.log_callback = log_callback ? log_callback : ggml_log_callback_default;
g_logger_state.log_callback_user_data = user_data;
overview / pkg / ggml / sources / whisper.cpp / commitdiff