#include "ggml.h"
#include "ggml-cpu.h"
#include <string.h>
#include <stdio.h>

int main(void) {
    // 行列積を実行するために行列のデータを初期化する
    const int rows_A = 4, cols_A = 2;
    float matrix_A[rows_A * cols_A] = {
        2, 8,
        5, 1,
        4, 2,
        8, 6
    };
    const int rows_B = 3, cols_B = 2;
    float matrix_B[rows_B * cols_B] = {
        10, 5,
        9, 9,
        5, 4
    };

    // 1. テンソルデータを格納するために`ggml_context`を割り当てる
    // 割り当てに必要なサイズを計算
    size_t ctx_size = 0;
    ctx_size += rows_A * cols_A * ggml_type_size(GGML_TYPE_F32); // tensor a
    ctx_size += rows_B * cols_B * ggml_type_size(GGML_TYPE_F32); // tensor b
    ctx_size += rows_A * rows_B * ggml_type_size(GGML_TYPE_F32); // result
    ctx_size += 3 * ggml_tensor_overhead(); // metadata for 3 tensors
    ctx_size += ggml_graph_overhead(); // compute graph
    ctx_size += 1024; // some overhead (exact calculation omitted for simplicity)

    // テンソルデータを格納するため`ggml_context`を作成
    struct ggml_init_params params = {
        /*.mem_size   =*/ ctx_size,
        /*.mem_buffer =*/ NULL,
        /*.no_alloc   =*/ false,
    };
    struct ggml_context * ctx = ggml_init(params);

    // 2. テンソルを作成しデータを格納
    struct ggml_tensor * tensor_a = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, cols_A, rows_A);
    struct ggml_tensor * tensor_b = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, cols_B, rows_B);
    memcpy(tensor_a->data, matrix_A, ggml_nbytes(tensor_a));
    memcpy(tensor_b->data, matrix_B, ggml_nbytes(tensor_b));


    // 3. 行列積操作のために`ggml_cgraph`を作成する
    struct ggml_cgraph * gf = ggml_new_graph(ctx);

    // result = a*b^T
    // 注意: ggml_mul_mat(A, B) を実行すると、B は内部で転置される
    // そのため、結果も転置される
    struct ggml_tensor * result = ggml_mul_mat(ctx, tensor_a, tensor_b);

    // result テンソルを計算対象としてマークする
    ggml_build_forward_expand(gf, result);

    // 4. 計算を実行
    int n_threads = 1; // Optional: number of threads to perform some operations with multi-threading
    ggml_graph_compute_with_ctx(ctx, gf, n_threads);

    // 5. 結果を取得する（出力テンソル）
    float * result_data = (float *) result->data;
    printf("mul mat (%d x %d) (transposed result):\n[", (int) result->ne[0], (int) result->ne[1]);
    for (int j = 0; j < result->ne[1] /* rows */; j++) {
        if (j > 0) {
            printf("\n");
        }

        for (int i = 0; i < result->ne[0] /* cols */; i++) {
            printf(" %.2f", result_data[j * result->ne[0] + i]);
        }
    }
    printf(" ]\n");

    // 6. メモリを解放して終了
    ggml_free(ctx);
    return 0;
}

#include "ggml.h"
#include "ggml-alloc.h"
#include "ggml-backend.h"
#ifdef GGML_USE_CUDA
#include "ggml-cuda.h"
#endif

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int main(void) {
    // 行列積を実行するための行列データを初期化
    const int rows_A = 4, cols_A = 2;
    float matrix_A[rows_A * cols_A] = {
        2, 8,
        5, 1,
        4, 2,
        8, 6
    };
    const int rows_B = 3, cols_B = 2;
    float matrix_B[rows_B * cols_B] = {
        10, 5,
        9, 9,
        5, 4
    };

    // 1. バックエンドを初期化
    ggml_backend_t backend = NULL;
#ifdef GGML_USE_CUDA
    fprintf(stderr, "%s: CUDA バックエンドを使用\n", __func__);
    backend = ggml_backend_cuda_init(0); // デバイス 0 を初期化
    if (!backend) {
        fprintf(stderr, "%s: ggml_backend_cuda_init() に失敗しました\n", __func__);
    }
#endif
    // GPU バックエンドがない場合は、CPU バックエンドにフォールバック
    if (!backend) {
        backend = ggml_backend_cpu_init();
    }

    // 必要なメモリサイズを計算
    size_t ctx_size = 0;
    ctx_size += 2 * ggml_tensor_overhead(); // テンソルのオーバーヘッドを考慮
    // それ以外の割り当ては不要

    // 2. `ggml_context` を割り当ててテンソルデータを保存
    struct ggml_init_params params = {
        /*.mem_size   =*/ ctx_size,
        /*.mem_buffer =*/ NULL,
        /*.no_alloc   =*/ true, // テンソルは後で ggml_backend_alloc_ctx_tensors() により割り当てられる
    };
    struct ggml_context * ctx = ggml_init(params);

    // テンソルのメタデータ（形状とデータ型のみ）を作成
    struct ggml_tensor * tensor_a = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, cols_A, rows_A);
    struct ggml_tensor * tensor_b = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, cols_B, rows_B);

    // 4. すべてのテンソルを格納するための `ggml_backend_buffer` を割り当て
    ggml_backend_buffer_t buffer = ggml_backend_alloc_ctx_tensors(ctx, backend);

    // 5. メインメモリ（RAM）からバックエンドバッファへテンソルデータをコピー
    ggml_backend_tensor_set(tensor_a, matrix_A, 0, ggml_nbytes(tensor_a));
    ggml_backend_tensor_set(tensor_b, matrix_B, 0, ggml_nbytes(tensor_b));

    // 6. 行列積のための `ggml_cgraph` を作成
    struct ggml_cgraph * gf = NULL;
    struct ggml_context * ctx_cgraph = NULL;
    {
        // 一時的なコンテキストを作成し、グラフを構築
        struct ggml_init_params params0 = {
            /*.mem_size   =*/ ggml_tensor_overhead() * GGML_DEFAULT_GRAPH_SIZE + ggml_graph_overhead(),
            /*.mem_buffer =*/ NULL,
            /*.no_alloc   =*/ true, // テンソルは後で ggml_gallocr_alloc_graph() により割り当てられる
        };
        ctx_cgraph = ggml_init(params0);
        gf = ggml_new_graph(ctx_cgraph);

        // result = A * B^T
        // 注意: ggml_mul_mat(A, B) は B を内部的に転置する
        // 結果も転置された形となる
        struct ggml_tensor * result0 = ggml_mul_mat(ctx_cgraph, tensor_a, tensor_b);

        // "result" テンソルとその依存関係をすべて計算グラフに追加
        ggml_build_forward_expand(gf, result0);
    }

    // 7. `ggml_gallocr` を作成して計算グラフ用のメモリを確保
    ggml_gallocr_t allocr = ggml_gallocr_new(ggml_backend_get_default_buffer_type(backend));
    ggml_gallocr_alloc_graph(allocr, gf);

    // （8. オプション: `ggml_backend_sched` を使用したスケジューリングは省略）

    // 9. 計算の実行
    int n_threads = 1; // オプション: 一部の処理をマルチスレッドで実行するスレッド数
    if (ggml_backend_is_cpu(backend)) {
        ggml_backend_cpu_set_n_threads(backend, n_threads);
    }
    ggml_backend_graph_compute(backend, gf);

    // 10. 計算結果（出力テンソル）を取得
    // この例では、出力テンソルは常にグラフの最後のノードとなる
    struct ggml_tensor * result = gf->nodes[gf->n_nodes - 1];
    float * result_data = malloc(ggml_nbytes(result));
    // テンソルデータはデバイスバッファに格納されているため、RAM にコピーする必要がある
    ggml_backend_tensor_get(result, result_data, 0, ggml_nbytes(result));
    printf("行列積 (%d x %d)（転置された結果）:\n[", (int) result->ne[0], (int) result->ne[1]);
    for (int j = 0; j < result->ne[1] /* 行数 */; j++) {
        if (j > 0) {
            printf("\n");
        }

        for (int i = 0; i < result->ne[0] /* 列数 */; i++) {
            printf(" %.2f", result_data[j * result->ne[0] + i]);
        }
    }
    printf(" ]\n");
    free(result_data);

    // 11. メモリを解放して終了
    ggml_free(ctx_cgraph);
    ggml_gallocr_free(allocr);
    ggml_free(ctx);
    ggml_backend_buffer_free(buffer);
    ggml_backend_free(backend);
    return 0;
}

    // 1. バックエンドを初期化
    ggml_backend_t backend = NULL;
#ifdef GGML_USE_CUDA
    fprintf(stderr, "%s: CUDA バックエンドを使用\n", __func__);
    backend = ggml_backend_cuda_init(0); // デバイス 0 を初期化
    if (!backend) {
        fprintf(stderr, "%s: ggml_backend_cuda_init() に失敗しました\n", __func__);
    }
#endif
    // GPU バックエンドがない場合は、CPU バックエンドにフォールバック
    if (!backend) {
        backend = ggml_backend_cpu_init();
    }

    // 必要なメモリサイズを計算
    size_t ctx_size = 0;
    ctx_size += 2 * ggml_tensor_overhead(); // テンソルのオーバーヘッドを考慮
    // それ以外の割り当ては不要

    // 2. `ggml_context` を割り当ててテンソルデータを保存
    struct ggml_init_params params = {
        /*.mem_size   =*/ ctx_size,
        /*.mem_buffer =*/ NULL,
        /*.no_alloc   =*/ true, // テンソルは後で ggml_backend_alloc_ctx_tensors() により割り当てられる
    };
    struct ggml_context * ctx = ggml_init(params);

    // 4. すべてのテンソルを格納するための `ggml_backend_buffer` を割り当て
    ggml_backend_buffer_t buffer = ggml_backend_alloc_ctx_tensors(ctx, backend);

    ggml_backend_tensor_set(tensor_a, matrix_A, 0, ggml_nbytes(tensor_a));
    ggml_backend_tensor_set(tensor_b, matrix_B, 0, ggml_nbytes(tensor_b));

    // 6. 行列積のための `ggml_cgraph` を作成
    struct ggml_cgraph * gf = NULL;
    struct ggml_context * ctx_cgraph = NULL;
    {
        // 一時的なコンテキストを作成し、グラフを構築
        struct ggml_init_params params0 = {
            /*.mem_size   =*/ ggml_tensor_overhead() * GGML_DEFAULT_GRAPH_SIZE + ggml_graph_overhead(),
            /*.mem_buffer =*/ NULL,
            /*.no_alloc   =*/ true, // テンソルは後で ggml_gallocr_alloc_graph() により割り当てられる
        };
        ctx_cgraph = ggml_init(params0);
        gf = ggml_new_graph(ctx_cgraph);
         ...

    // 7. `ggml_gallocr` を作成して計算グラフ用のメモリを確保
    ggml_gallocr_t allocr = ggml_gallocr_new(ggml_backend_get_default_buffer_type(backend));
    ggml_gallocr_alloc_graph(allocr, gf);

    struct ggml_tensor * result = gf->nodes[gf->n_nodes - 1];
    float * result_data = malloc(ggml_nbytes(result));
    // テンソルデータはデバイスバッファに格納されているため、RAM にコピーする必要がある
    ggml_backend_tensor_get(result, result_data, 0, ggml_nbytes(result));
    printf("行列積 (%d x %d)（転置された結果）:\n[", (int) result->ne[0], (int) result->ne[1]);
    for (int j = 0; j < result->ne[1] /* 行数 */; j++) {
        if (j > 0) {
            printf("\n");
        }

        for (int i = 0; i < result->ne[0] /* 列数 */; i++) {
            printf(" %.2f", result_data[j * result->ne[0] + i]);
        }
    }
    printf(" ]\n");
    free(result_data);

index = key % hash_size;
<!-- たとえばkeyはテンソルのアドレス -->