cleanup unused examples

examples/diffusion/README.md

@@ -1,59 +0,0 @@
-# Diffusion Text Generation
-
-This directory contains implementations for Diffusion LLMs (DLLMs)
-
-More Info:
-- https://github.com/ggml-org/llama.cpp/pull/14644
-- https://github.com/ggml-org/llama.cpp/pull/14771
-
-## Parameters
-The diffusion CLI supports various parameters to control the generation process:
-
-### Core Diffusion Parameters
-- `--diffusion-steps`: Number of diffusion steps (default: 256)
-- `--diffusion-algorithm`: Algorithm for token selection
-  - `0`: DIFFUSION_ALGORITHM_ORIGIN - Token will be generated in a purely random order from https://arxiv.org/abs/2107.03006.
-  - `1`: DIFFUSION_ALGORITHM_ENTROPY_BASED - Entropy-based selection
-  - `2`: DIFFUSION_ALGORITHM_MARGIN_BASED - Margin-based selection
-  - `3`: DIFFUSION_ALGORITHM_RANDOM - Random selection
-  - `4`: DIFFUSION_ALGORITHM_CONFIDENCE_BASED - Confidence-based selection (default)
-  - More documentation here https://github.com/DreamLM/Dream
-- `--diffusion-visual`: Enable live visualization during generation
-
-### Scheduling Parameters
-Choose one of the following scheduling methods:
-
-**Timestep-based scheduling:**
-- `--diffusion-eps`: Epsilon value for timestep scheduling (e.g., 0.001)
-
-**Block-based scheduling:**
-- `--diffusion-block-length`: Block size for block-based scheduling (e.g., 32)
-
-### Sampling Parameters
-- `--temp`: Temperature for sampling (0.0 = greedy/deterministic, higher = more random)
-- `--top-k`: Top-k filtering for sampling
-- `--top-p`: Top-p (nucleus) filtering for sampling
-- `--seed`: Random seed for reproducibility
-
-### Model Parameters
-- `-m`: Path to the GGUF model file
-- `-p`: Input prompt text
-- `-ub`: Maximum sequence length (ubatch size)
-- `-c`: Context size
-- `-b`: Batch size
-
-### Examples
-#### Dream architecture:
-```
-llama-diffusion-cli -m dream7b.gguf -p "write code to train MNIST in pytorch" -ub 512 --diffusion-eps 0.001 --diffusion-algorithm 3 --diffusion-steps 256 --diffusion-visual
-```
-
-#### LLaDA architecture:
-```
-llama-diffusion-cli -m llada-8b.gguf -p "write code to train MNIST in pytorch" -ub 512 --diffusion-block-length 32 --diffusion-steps 256 --diffusion-visual
-```
-
-#### RND1 architecture:
-```
-llama-diffusion-cli -m RND1-Base-0910.gguf -p "write code to train MNIST in pytorch" -ub 512 --diffusion-algorithm 1 --diffusion-steps 256 --diffusion-visual --temp 0.5 --diffusion-eps 0.001
-```

examples/diffusion/diffusion-cli.cpp

@@ -1,266 +0,0 @@
-#include "arg.h"
-#include "chat.h"
-#include "common.h"
-#include "diffusion.h"
-#include "llama.h"
-#include "log.h"
-
-#include <limits.h>
-
-#include <clocale>
-#include <cstring>
-#include <string>
-#include <vector>
-
-struct callback_data {
-    diffusion_params *  diff_params;
-    const llama_vocab * vocab;
-    int32_t             n_input;
-};
-
-static bool diffusion_step_callback(int32_t             step,
-                                    int32_t             total_steps,
-                                    const llama_token * tokens,
-                                    int32_t             n_tokens,
-                                    void *              user_data) {
-    (void) user_data;
-
-    callback_data * data = static_cast<callback_data *>(user_data);
-
-    auto print_progress_bar = [](int32_t step, int32_t total_steps) {
-        int progress_percent = (step * 100) / total_steps;
-        int progress_bars    = (step * 50) / total_steps;
-        LOG_INF("\rdiffusion step: %d/%d [%s%s] %d%%",
-                step,
-                total_steps,
-                std::string(progress_bars, '=').c_str(),
-                std::string(50 - progress_bars, ' ').c_str(),
-                progress_percent);
-    };
-
-    if (data->diff_params->visual_mode) {
-        // Visual mode: clear
-        LOG_INF("\033[2J\033[H");  // Clear screen and move cursor to top-left
-
-        print_progress_bar(step, total_steps);
-
-        LOG_INF("\n");
-
-        std::string current_text = " ";
-
-        for (int32_t i = data->n_input; i < n_tokens; i++) {
-            std::string token_str;
-            if (tokens[i] != llama_vocab_mask(data->vocab)) {
-                char piece[256];
-                int  n_chars = llama_token_to_piece(data->vocab, tokens[i], piece, sizeof(piece), 0, false);
-                if (n_chars > 0) {
-                    piece[n_chars] = '\0';
-                    token_str      = piece;
-                }
-            } else {
-                token_str = " ";
-            }
-
-            current_text += token_str;
-        }
-
-        LOG_INF("%s\n", current_text.c_str());
-    } else {
-        print_progress_bar(step, total_steps);
-    }
-
-    return true;
-}
-
-static std::string format_input_text(const std::string & prompt, const std::string & system_prompt, bool use_chat_template, llama_model * model) {
-    if (!use_chat_template) {
-        return prompt;
-    }
-
-    auto chat_templates = common_chat_templates_init(model, "");
-    common_chat_templates_inputs inputs;
-    common_chat_msg system_msg;
-
-    if (!system_prompt.empty()) {
-        system_msg.role = "system";
-        system_msg.content = system_prompt;
-        inputs.messages.push_back(system_msg);
-    }
-
-    common_chat_msg user_msg;
-    user_msg.role = "user";
-    user_msg.content = prompt;
-
-    inputs.messages.push_back(user_msg);
-    inputs.add_generation_prompt = true;
-
-    auto result = common_chat_templates_apply(chat_templates.get(), inputs);
-
-    return result.prompt;
-}
-
-int main(int argc, char ** argv) {
-    std::setlocale(LC_NUMERIC, "C");
-
-    ggml_time_init();
-
-    common_params params;
-
-    common_init();
-
-    if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_DIFFUSION)) {
-        return 1;
-    }
-
-    llama_backend_init();
-
-    llama_model_params model_params = llama_model_default_params();
-    model_params.n_gpu_layers       = params.n_gpu_layers;
-    model_params.devices            = params.devices.data();
-    model_params.load_mode          = params.load_mode;
-    model_params.check_tensors      = params.check_tensors;
-
-    llama_model * model = llama_model_load_from_file(params.model.path.c_str(), model_params);
-    if (!model) {
-        LOG_ERR("error: failed to load model '%s'\n", params.model.path.c_str());
-        return 1;
-    }
-
-    if (!llama_model_is_diffusion(model)) {
-        LOG_ERR("error: unsupported model for diffusion");
-        llama_model_free(model);
-        return 1;
-    }
-
-    llama_context_params ctx_params = llama_context_default_params();
-    ctx_params.n_ctx                = params.n_ctx;
-    ctx_params.n_batch              = params.n_batch;
-    ctx_params.n_ubatch             = params.n_ubatch;
-    ctx_params.flash_attn_type      = params.flash_attn_type;
-    ctx_params.no_perf              = params.no_perf;
-    ctx_params.type_k               = params.cache_type_k;
-    ctx_params.type_v               = params.cache_type_v;
-
-    llama_context * ctx = llama_init_from_model(model, ctx_params);
-    if (!ctx) {
-        LOG_ERR("error: failed to create context\n");
-        llama_model_free(model);
-        return 1;
-    }
-
-    llama_set_n_threads(ctx, params.cpuparams.n_threads, params.cpuparams_batch.n_threads);
-
-    const llama_vocab * vocab            = llama_model_get_vocab(model);
-
-    std::string         formatted_prompt = format_input_text(params.prompt, params.system_prompt, params.enable_chat_template, model);
-
-    std::vector<llama_token> input_tokens = common_tokenize(vocab,
-                                                            formatted_prompt,
-                                                            /*add special tokens*/ true,
-                                                            /*parse special*/ true);
-
-    int n_input = input_tokens.size();
-
-    if (static_cast<uint32_t>(n_input) >= llama_n_ctx(ctx)) {
-        LOG_ERR("error: input too long (%d tokens), max context is %d\n", n_input, llama_n_ctx(ctx));
-        llama_free(ctx);
-        llama_model_free(model);
-        return 1;
-    }
-
-    llama_token mask_token_id = llama_vocab_mask(vocab);
-
-    GGML_ASSERT(mask_token_id != LLAMA_TOKEN_NULL);
-
-    bool visual_mode = params.diffusion.visual_mode;
-
-    int32_t                  n_generated = 0;
-    std::vector<llama_token> output_tokens(params.n_ubatch);
-
-    struct diffusion_params diff_params;
-
-    char shift_logits_str[8];
-    if (llama_model_meta_val_str(model, "diffusion.shift_logits", shift_logits_str, sizeof(shift_logits_str)) >= 0) {
-        diff_params.shift_logits = (strcmp(shift_logits_str, "true") == 0);
-    } else {
-        diff_params.shift_logits = true;
-    }
-
-    //Use either eps or block length, but not both
-    GGML_ASSERT((params.diffusion.eps == 0) ^ (params.diffusion.block_length == 0));
-
-    if (params.diffusion.eps) {
-        diff_params.schedule = DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED;
-        diff_params.eps      = params.diffusion.eps;
-    } else if (params.diffusion.block_length) {
-        diff_params.schedule     = DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED;
-        diff_params.block_length = params.diffusion.block_length;
-    }
-
-    diff_params.mask_token_id    = mask_token_id;
-    diff_params.seed             = params.sampling.seed;
-    diff_params.temperature      = params.sampling.temp;
-    diff_params.steps            = params.diffusion.steps;
-    diff_params.algorithm        = static_cast<diffusion_algorithm>(params.diffusion.algorithm);
-    diff_params.max_length       = params.n_ubatch;
-    diff_params.top_p            = params.sampling.top_p;
-    diff_params.top_k            = params.sampling.top_k;
-    diff_params.visual_mode      = params.diffusion.visual_mode;
-    diff_params.add_gumbel_noise = params.diffusion.add_gumbel_noise;
-
-    diff_params.step_callback           = diffusion_step_callback;
-    callback_data cb_data               = { &diff_params, vocab, n_input };
-    diff_params.step_callback_user_data = &cb_data;
-
-    const char * alg_names[]   = {
-        "DIFFUSION_ALGORITHM_ORIGIN",
-        "DIFFUSION_ALGORITHM_ENTROPY_BASED",
-        "DIFFUSION_ALGORITHM_MARGIN_BASED",
-        "DIFFUSION_ALGORITHM_RANDOM",
-        "DIFFUSION_ALGORITHM_CONFIDENCE_BASED",
-    };
-    const char * sched_names[] = {
-        "DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED",
-        "DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED",
-    };
-    const char * alg_name =
-        (diff_params.algorithm >= 0 && diff_params.algorithm <= 4) ? alg_names[diff_params.algorithm] : "UNKNOWN";
-    const char * sched_name =
-        (diff_params.schedule >= 0 && diff_params.schedule <= 1) ? sched_names[diff_params.schedule] : "UNKNOWN";
-
-    LOG_INF("diffusion_params: - %-25s llama_token      = %d\n", "mask_token_id", mask_token_id);
-    LOG_INF("diffusion_params: - %-25s u32              = %d\n", "steps", diff_params.steps);
-    LOG_INF("diffusion_params: - %-25s u32              = %d\n", "max_length", diff_params.max_length);
-    LOG_INF("diffusion_params: - %-25s enum             = %d (%s)\n", "algorithm", diff_params.algorithm, alg_name);
-    LOG_INF("diffusion_params: - %-25s enum             = %d (%s)\n", "schedule", diff_params.schedule, sched_name);
-    LOG_INF("diffusion_params: - %-25s f32              = %.3f\n", "temperature", diff_params.temperature);
-    if (diff_params.schedule == DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED) {
-        LOG_INF("diffusion_params: - %-25s f32              = %.6f\n", "eps", diff_params.eps);
-        LOG_INF("diffusion_params: - %-25s f32              = %.3f\n", "alg_temp", diff_params.alg_temp);
-    }
-    if (diff_params.schedule == DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED) {
-        LOG_INF("diffusion_params: - %-25s u32              = %d\n", "block_length", diff_params.block_length);
-        LOG_INF("diffusion_params: - %-25s f32              = %.3f\n", "cfg_scale", diff_params.cfg_scale);
-    }
-
-    diffusion_generate(ctx, input_tokens.data(), output_tokens.data(), n_input, diff_params, n_generated);
-
-    if (n_generated > 0) {
-        if (visual_mode) {
-            //clear screen and move cursor to top-left
-            LOG_INF("\033[2J\033[H");
-        }
-
-        output_tokens.erase(output_tokens.begin(), output_tokens.begin() + n_input);
-        std::string output_data = common_detokenize(vocab, output_tokens, false);
-        LOG_INF("\n%s\n", output_data.c_str());
-    } else {
-        LOG_INF("Error: diffusion generation failed\n");
-    }
-
-    llama_free(ctx);
-    llama_model_free(model);
-    llama_backend_free();
-
-    return 0;
-}

examples/diffusion/diffusion.cpp

@@ -1,406 +0,0 @@
-#include "diffusion.h"
-
-#include "common.h"
-
-#include "log.h"
-
-#include <algorithm>
-#include <cstddef>
-#include <cmath>
-#include <cstring>
-#include <random>
-#include <utility>
-#include <vector>
-
-static float calculate_confidence(const llama_token_data_array & cur_p,
-                                  diffusion_algorithm            algorithm,
-                                  std::mt19937 &                 rng) {
-    switch (algorithm) {
-        case DIFFUSION_ALGORITHM_CONFIDENCE_BASED:
-            return cur_p.data[cur_p.selected].p;  // Selected token probability
-
-        case DIFFUSION_ALGORITHM_ENTROPY_BASED:
-            {
-                float       entropy = 0.0f;
-                const float epsilon = 1e-10f;
-                for (size_t i = 0; i < cur_p.size; i++) {
-                    float prob = cur_p.data[i].p;
-                    entropy += prob * logf(prob + epsilon);
-                }
-                return -entropy;  // Higher entropy = lower confidence
-            }
-
-        case DIFFUSION_ALGORITHM_MARGIN_BASED:
-            return (cur_p.size > 1) ? cur_p.data[0].p - cur_p.data[1].p : cur_p.data[0].p;
-
-        case DIFFUSION_ALGORITHM_RANDOM:
-            {
-                std::uniform_real_distribution<float> uniform(0.0f, 1.0f);
-                return uniform(rng);  // Random confidence
-            }
-
-        case DIFFUSION_ALGORITHM_ORIGIN:
-            return cur_p.data[cur_p.selected].p;
-
-        default:
-            return 0.0f;
-    }
-}
-
-// Unified transfer count calculation function
-static int32_t calculate_transfer_count(int32_t                      step,
-                                        int32_t                      total_steps,
-                                        int32_t                      remaining_masked,
-                                        diffusion_transfer_schedule  schedule,
-                                        float                        eps,
-                                        const std::vector<int32_t> & num_transfer_tokens = {}) {
-    switch (schedule) {
-        case DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED:
-            {
-                float t          = 1.0f - (float) step / total_steps * (1.0f - eps);
-                float s          = 1.0f - (float) (step + 1) / total_steps * (1.0f - eps);
-                float p_transfer = (step < total_steps - 1) ? (1.0f - s / t) : 1.0f;
-                return (int32_t) (remaining_masked * p_transfer);
-            }
-
-        case DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED:
-            if (!num_transfer_tokens.empty() && step < (int32_t) num_transfer_tokens.size()) {
-                return num_transfer_tokens[step];
-            }
-            return remaining_masked / (total_steps - step);  // Fallback
-
-        default:
-            return remaining_masked / (total_steps - step);
-    }
-}
-
-static void add_gumbel_noise(float * logits, int32_t n_vocab, float temperature, std::mt19937 & rng) {
-    if (temperature == 0.0f) {
-        return;
-    }
-
-    std::uniform_real_distribution<double> uniform(0.0, 1.0);
-    for (int32_t i = 0; i < n_vocab; i++) {
-        double noise        = uniform(rng);
-        // Prevent log(0)
-        noise               = std::max(noise, 1e-20);
-        double gumbel_noise = std::pow(-std::log(noise), temperature);
-        logits[i]           = std::exp(logits[i]) / gumbel_noise;
-    }
-}
-
-static std::vector<int32_t> get_num_transfer_tokens(int32_t mask_count, int32_t steps) {
-    std::vector<int32_t> num_transfer_tokens(steps);
-
-    int32_t base      = mask_count / steps;
-    int32_t remainder = mask_count % steps;
-
-    for (int32_t i = 0; i < steps; i++) {
-        num_transfer_tokens[i] = base + (i < remainder ? 1 : 0);
-    }
-
-    return num_transfer_tokens;
-}
-
-void diffusion_generate(llama_context *          ctx,
-                        const llama_token *      input_tokens,
-                        llama_token *            output_tokens,
-                        int32_t                  n_input,
-                        const diffusion_params & params,
-                        int32_t &                n_generated) {
-    n_generated = 0;
-    if (!ctx || !input_tokens || !output_tokens || n_input <= 0 || params.max_length <= n_input) {
-        return;
-    }
-
-    const llama_model * model = llama_get_model(ctx);
-
-    // Initialize with input and pad with mask tokens
-    std::copy(input_tokens, input_tokens + n_input, output_tokens);
-    std::fill(output_tokens + n_input, output_tokens + params.max_length, params.mask_token_id);
-
-    std::mt19937 rng(params.seed);
-
-    llama_set_causal_attn(ctx, false);
-
-    int32_t n_vocab = llama_vocab_n_tokens(llama_model_get_vocab(model));
-
-    std::vector<llama_token_data> candidates(n_vocab);
-    std::vector<llama_token_data> conf_candidates;
-    conf_candidates.reserve(params.max_length);
-    std::vector<int32_t> mask_positions;
-    mask_positions.reserve(params.max_length);
-
-    // Setup sampler chain
-    struct llama_sampler * sampler = llama_sampler_chain_init(llama_sampler_chain_default_params());
-    if (params.top_k > 0) {
-        llama_sampler_chain_add(sampler, llama_sampler_init_top_k(params.top_k));
-    }
-    if (params.top_p < 1.0f) {
-        llama_sampler_chain_add(sampler, llama_sampler_init_top_p(params.top_p, 1));
-    }
-    if (params.temperature > 0.0f) {
-        llama_sampler_chain_add(sampler, llama_sampler_init_temp(params.temperature));
-    }
-    llama_sampler_chain_add(sampler, llama_sampler_init_dist(params.seed));
-
-    struct llama_sampler * dist_sampler = llama_sampler_init_dist(params.seed);
-
-    common_batch batch(ctx);
-
-    // Pre-allocate buffers for CFG if needed
-    int32_t                  logits_size = n_vocab * params.max_length;
-    std::vector<float>       cond_logits_buffer;
-    std::vector<llama_token> un_x_buffer;
-    if (params.cfg_scale > 0.0f) {
-        cond_logits_buffer.resize(logits_size);
-        un_x_buffer.resize(params.max_length);
-    }
-
-    // For block-based processing
-    std::vector<int32_t> num_transfer_tokens;
-    int32_t              num_blocks      = 1;
-    int32_t              steps_per_block = params.steps;
-
-    if (params.schedule == DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED) {
-        GGML_ASSERT(params.max_length % params.block_length == 0);
-        num_blocks = params.max_length / params.block_length;
-        GGML_ASSERT(params.steps % num_blocks == 0);
-        steps_per_block = params.steps / num_blocks;
-    }
-
-    std::vector<float> confidence(params.max_length);
-
-    int64_t total_sampling_time = 0;
-    int64_t total_time          = 0;
-    int64_t time_start          = ggml_time_us();
-
-    for (int block_num = 0; block_num < num_blocks; block_num++) {
-        int32_t block_start = (params.schedule == DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED) ? n_input + block_num * params.block_length : 0;
-        int32_t block_end   = (params.schedule == DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED) ?
-                                  std::min(n_input + (block_num + 1) * params.block_length, params.max_length) :
-                                  params.max_length;
-
-        // Count masked tokens in current block for block-based processing
-        if (params.schedule == DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED) {
-            int32_t block_mask_count = 0;
-            for (int i = block_start; i < block_end; i++) {
-                if (output_tokens[i] == params.mask_token_id) {
-                    block_mask_count++;
-                }
-            }
-            num_transfer_tokens = get_num_transfer_tokens(block_mask_count, steps_per_block);
-        }
-
-        for (int32_t step = 0; step < steps_per_block; step++) {
-            int32_t global_step = block_num * steps_per_block + step;
-
-            if (params.step_callback) {
-                if (!params.step_callback(
-                        global_step, params.steps, output_tokens, params.max_length, params.step_callback_user_data)) {
-                    break;
-                }
-            }
-
-            // Setup batch
-            batch.clear();
-            for (int32_t i = 0; i < params.max_length; i++) {
-                batch.add(output_tokens[i], i, 0, true);
-            }
-
-            float * logits = nullptr;
-
-            if (params.cfg_scale > 0.0f) {
-                int ret = llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch.get());
-                if (ret != 0) {
-                    LOG_ERR("Failed to generate conditional");
-                    break;
-                }
-                float * cond_logits_ptr = llama_get_logits(ctx);
-                std::memcpy(cond_logits_buffer.data(), cond_logits_ptr, logits_size * sizeof(float));
-
-                // Unconditional generation (mask input)
-                std::copy(output_tokens, output_tokens + params.max_length, un_x_buffer.begin());
-                for (int32_t i = 0; i < n_input; i++) {
-                    un_x_buffer[i] = params.mask_token_id;
-                }
-
-                batch.clear();
-                for (int32_t i = 0; i < params.max_length; i++) {
-                    batch.add(un_x_buffer[i], i, 0, true);
-                }
-                ret = llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch.get());
-                if (ret != 0) {
-                    LOG_ERR("Failed to generate unconditional");
-                    break;
-                }
-                float * uncond_logits = llama_get_logits(ctx);
-
-                // Apply CFG
-                for (int32_t i = 0; i < logits_size; i++) {
-                    cond_logits_buffer[i] =
-                        uncond_logits[i] + (params.cfg_scale + 1.0f) * (cond_logits_buffer[i] - uncond_logits[i]);
-                }
-                logits = cond_logits_buffer.data();
-            } else {
-                int ret = llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch.get());
-                if (ret != 0) {
-                    LOG_ERR("%s: failed to decode at step %d, ret = %d\n", __func__, global_step, ret);
-                    break;
-                }
-                logits = llama_get_logits(ctx);
-            }
-
-            if (!logits) {
-                LOG_ERR("%s: failed to get logits at step %d\n", __func__, global_step);
-                break;
-            }
-
-            auto get_logits_for_pos = [&](int32_t pos) -> const float * {
-                if (params.shift_logits) {
-                    return pos == 0 ? logits : logits + (pos - 1) * n_vocab;
-                }
-                return logits + pos * n_vocab;
-            };
-
-            int64_t time_start_sampling = ggml_time_us();
-
-            mask_positions.clear();
-            for (int32_t i = 0; i < params.max_length; i++) {
-                if (output_tokens[i] == params.mask_token_id) {
-                    // For block-based, only consider current block
-                    if (params.schedule != DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED || (i >= block_start && i < block_end)) {
-                        mask_positions.push_back(i);
-                    }
-                }
-            }
-
-            if (mask_positions.empty()) {
-                break;
-            }
-
-            if (params.add_gumbel_noise && params.temperature > 0.0f) {
-                add_gumbel_noise(logits, n_vocab, params.temperature, rng);
-            }
-
-            if (params.algorithm == DIFFUSION_ALGORITHM_ORIGIN) {
-                int32_t transfer_count = calculate_transfer_count(
-                    step, steps_per_block, mask_positions.size(), params.schedule, params.eps, num_transfer_tokens);
-                float p_transfer = (float) transfer_count / mask_positions.size();
-
-                for (int32_t pos : mask_positions) {
-                    if (std::uniform_real_distribution<float>(0.0f, 1.0f)(rng) < p_transfer) {
-                        const float * pos_logits = get_logits_for_pos(pos);
-                        for (int32_t token_id = 0; token_id < n_vocab; token_id++) {
-                            candidates[token_id].id    = token_id;
-                            candidates[token_id].logit = pos_logits[token_id];
-                            candidates[token_id].p     = 0.0f;
-                        }
-
-                        llama_token_data_array cur_p = {
-                            candidates.data(),
-                            (size_t) n_vocab,
-                            -1,
-                            false,
-                        };
-
-                        llama_sampler_apply(sampler, &cur_p);
-                        output_tokens[pos] = cur_p.data[cur_p.selected].id;
-                    }
-                }
-            } else {
-                std::vector<std::pair<float, int32_t>> confidences;
-                std::vector<llama_token>               sampled_tokens(mask_positions.size());
-
-                for (size_t i = 0; i < mask_positions.size(); i++) {
-                    int32_t       pos        = mask_positions[i];
-                    const float * pos_logits = get_logits_for_pos(pos);
-
-                    for (int32_t token_id = 0; token_id < n_vocab; token_id++) {
-                        candidates[token_id].logit = pos_logits[token_id];
-                        candidates[token_id].p     = 0.0f;
-                        candidates[token_id].id    = token_id;
-                    }
-
-                    llama_token_data_array cur_p = {
-                        candidates.data(),
-                        candidates.size(),
-                        -1,
-                        false,
-                    };
-
-                    llama_sampler_apply(sampler, &cur_p);
-                    llama_token sampled_token = cur_p.data[cur_p.selected].id;
-
-                    float conf = calculate_confidence(cur_p, params.algorithm, rng);
-
-                    sampled_tokens[i] = sampled_token;
-                    confidences.emplace_back(conf, i);
-                }
-
-                int32_t transfer_count = calculate_transfer_count(
-                    step, steps_per_block, mask_positions.size(), params.schedule, params.eps, num_transfer_tokens);
-
-                if (transfer_count > 0) {
-                    if (params.alg_temp == 0.0f) {
-                        std::partial_sort(confidences.begin(),
-                                          confidences.begin() + std::min(transfer_count, (int32_t) confidences.size()),
-                                          confidences.end(),
-                                          [](const std::pair<float, int32_t> & a, const std::pair<float, int32_t> & b) {
-                                              if (a.first != b.first) {
-                                                  return a.first > b.first;
-                                              }
-                                              return a.second < b.second;
-                                          });
-
-                        for (int32_t i = 0; i < std::min(transfer_count, (int32_t) confidences.size()); i++) {
-                            int32_t mask_idx   = confidences[i].second;
-                            int32_t pos        = mask_positions[mask_idx];
-                            output_tokens[pos] = sampled_tokens[mask_idx];
-                        }
-                    } else {
-                        conf_candidates.clear();
-                        for (size_t i = 0; i < confidences.size(); i++) {
-                            float conf_logit = confidences[i].first / params.alg_temp;
-                            conf_candidates.emplace_back(llama_token_data{ (int32_t) i, conf_logit, 0.0f });
-                        }
-
-                        llama_token_data_array conf_array = {
-                            conf_candidates.data(),
-                            conf_candidates.size(),
-                            -1,
-                            false,
-                        };
-
-                        for (int32_t i = 0; i < std::min(transfer_count, (int32_t) confidences.size()); i++) {
-                            llama_sampler_apply(dist_sampler, &conf_array);
-                            int32_t selected_idx = conf_array.selected;
-                            int32_t mask_idx     = selected_idx;
-                            int32_t pos          = mask_positions[mask_idx];
-                            output_tokens[pos]   = sampled_tokens[mask_idx];
-
-                            conf_candidates[selected_idx].p = 0.0f;
-                            conf_array.selected             = -1;
-                        }
-                    }
-                }
-            }
-
-            int64_t time_end_sampling = ggml_time_us();
-            total_sampling_time += time_end_sampling - time_start_sampling;
-        }
-    }
-
-    int64_t time_end = ggml_time_us();
-    total_time += time_end - time_start;
-
-    LOG_INF("\ntotal time: %0.2fms, time per step: %0.2fms, sampling time per step: %0.2fms\n",
-            total_time / 1000.0,
-            total_time / 1000.0 / params.steps,
-            total_sampling_time / 1000.0 / params.steps);
-
-    llama_sampler_free(sampler);
-    llama_sampler_free(dist_sampler);
-
-    n_generated = params.max_length;
-}

examples/diffusion/diffusion.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include "llama.h"
-
-#include <cstdint>
-
-enum diffusion_algorithm {
-    DIFFUSION_ALGORITHM_ORIGIN           = 0,
-    DIFFUSION_ALGORITHM_ENTROPY_BASED    = 1,
-    DIFFUSION_ALGORITHM_MARGIN_BASED     = 2,
-    DIFFUSION_ALGORITHM_RANDOM           = 3,
-    DIFFUSION_ALGORITHM_CONFIDENCE_BASED = 4,
-};
-
-// Unified transfer scheduling methods
-enum diffusion_transfer_schedule {
-    DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED = 0,  // Dream-style: (1.0 - s/t) * remaining
-    DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED    = 1,  // LLaDA-style: process in blocks with get_num_transfer_tokens
-};
-
-typedef bool (*diffusion_step_callback_t)(int32_t             step,
-                                          int32_t             total_steps,
-                                          const llama_token * tokens,
-                                          int32_t             n_tokens,
-                                          void *              user_data);
-
-struct diffusion_params {
-    int32_t                   steps                   = 0;
-    float                     temperature             = 0;
-    llama_token               mask_token_id           = LLAMA_TOKEN_NULL;
-    diffusion_step_callback_t step_callback           = nullptr;
-    void *                    step_callback_user_data = nullptr;
-    int32_t                   seed                    = 0;
-    bool                      visual_mode             = false;
-    bool                      shift_logits            = false;  // Shift logits by -1 after decode
-
-    float   top_p = 0.;
-    int32_t top_k = 0.;
-
-    diffusion_algorithm         algorithm = DIFFUSION_ALGORITHM_CONFIDENCE_BASED;
-    diffusion_transfer_schedule schedule  = DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED;
-
-    float   cfg_scale        = 0.;     // Config scale for classifier-free guidance
-    float   eps              = 0.;     // Timestep scheduling
-    int32_t block_length     = 0;      // Block size (for block scheduling)
-    float   alg_temp         = 0;      // algorithm temperature (0.0 = deterministic)
-    bool    add_gumbel_noise = false;  // Add gumbel noise to the logits if temp > 0.0
-
-    int32_t max_length = 0;            // Maximum sequence length
-};
-
-void diffusion_generate(llama_context *          ctx,
-                        const llama_token *      input_tokens,
-                        llama_token *            output_tokens,
-                        int32_t                  n_input,
-                        const diffusion_params & params,
-                        int32_t &                n_generated);

examples/llama-eval/README.md

@@ -1,26 +0,0 @@
-# llama-eval
-
-Simple evaluation tool for llama.cpp with support for multiple datasets.
-
-For a full description, usage examples, and sample results, see:
-
-- [PR 21152](https://github.com/ggml-org/llama.cpp/pull/21152)
-
-## Quick start
-
-```bash
-# Single server
-python3 llama-eval.py \
-  --server http://localhost:8033 \
-  --model my-model \
-  --dataset gsm8k --n_cases 100 \
-  --grader-type regex --threads 32
-
-# Multiple servers (comma-separated URLs and thread counts)
-python3 llama-eval.py \
-  --server http://server1:8033,http://server2:8033 \
-  --server-name server1,server2 \
-  --threads 16,16 \
-  --dataset aime2025 --n_cases 240 \
-  --grader-type regex
-```

examples/llama-eval/llama-server-simulator.py

@@ -1,376 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import json
-import random
-import re
-import time
-import sys
-import os
-import threading
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from typing import Dict, List, Optional
-from dataclasses import dataclass
-from pathlib import Path
-
-import datasets
-
-# Set cache directory for HuggingFace datasets
-cache_dir = Path.home() / ".cache" / "huggingface" / "datasets"
-cache_dir.mkdir(parents=True, exist_ok=True)
-os.environ["HF_DATASETS_CACHE"] = str(cache_dir)
-
-def dice(s1: str, s2: str) -> float:
-    """Calculate Dice coefficient between two strings based on bigram overlap."""
-    if not s1 and not s2:
-        return 1.0
-
-    def _bigrams(s: str):
-        return [s[i : i + 2] for i in range(len(s) - 1)]
-
-    bigrams1 = _bigrams(s1)
-    bigrams2 = _bigrams(s2)
-
-    if not bigrams1 and not bigrams2:
-        return 1.0
-
-    from collections import Counter
-
-    freq1 = Counter(bigrams1)
-    freq2 = Counter(bigrams2)
-
-    intersection = sum(min(freq1[bg], freq2[bg]) for bg in freq1)
-    dice_coeff = 2 * intersection / (len(bigrams1) + len(bigrams2))
-    return dice_coeff
-
-def debug_log(message: str):
-    """Log debug messages to both stdout and a file"""
-    print(message, file=sys.stderr)
-    with open("/tmp/simulator-debug.log", "a") as f:
-        f.write(message + "\n")
-
-simulator: Optional["Simulator"] = None
-
-@dataclass
-class EvalState:
-    id: str
-    tasks: List[str]
-    task_states: Dict[str, Dict]
-    sampling_config: Dict
-
-def normalize_number(s: str) -> Optional[int]:
-    match = re.match(r"\d+", s)  # match digits from the start
-    if not match:
-        return None
-    return int(match.group(0))
-
-class AimeDataset:
-    def __init__(self, split: str = "train", dataset_type: str = "aime"):
-        self.split = split
-        self.dataset_type = dataset_type
-        self.questions: List[Dict] = []
-        self._load_dataset()
-
-    def _get_question_text(self, question: Dict) -> str:
-        """Get question text, handling different dataset field names."""
-        return question.get("problem", question.get("question", ""))
-
-    def _load_dataset(self):
-        if self.dataset_type == "aime":
-            print(f"Loading AIME dataset (split: {self.split})...")
-            cache_path = Path.home() / ".cache" / "huggingface" / "datasets" / "AI-MO___aimo-validation-aime" / "default" / "0.0.0"
-            if cache_path.exists():
-                print(f"Using cached dataset from {cache_path}")
-                ds = datasets.load_dataset("AI-MO/aimo-validation-aime", split=self.split, cache_dir=str(cache_path))
-            else:
-                ds = datasets.load_dataset("AI-MO/aimo-validation-aime", split=self.split)
-        elif self.dataset_type == "aime2025":
-            print(f"Loading AIME2025 dataset...")
-            ds_list = []
-            for config_name in ["AIME2025-I", "AIME2025-II"]:
-                cache_path = Path.home() / ".cache" / "huggingface" / "datasets" / "opencompass___AIME2025" / "default" / "0.0.0"
-                if cache_path.exists():
-                    print(f"Using cached dataset from {cache_path}")
-                    ds = datasets.load_dataset("opencompass/AIME2025", config_name, split="test", cache_dir=str(cache_path))
-                else:
-                    ds = datasets.load_dataset("opencompass/AIME2025", config_name, split="test")
-                ds_list.extend(ds)
-            ds = ds_list
-        else:
-            raise ValueError(f"Unknown dataset type: {self.dataset_type}")
-
-        self.questions = list(ds)
-        print(f"{self.dataset_type} dataset loaded: {len(self.questions)} questions")
-
-    def find_question(self, request_text: str) -> Optional[Dict]:
-        # Strip common template prefixes to get the actual question text
-        # Templates include things like "Solve the following math problem step by step..."
-        # The actual question usually follows a blank line or after the template instruction
-        cleaned = request_text
-        # Split on double newline and take the part that looks like the problem
-        parts = cleaned.split('\n\n')
-        if len(parts) > 1:
-            # Find the part that's longest (likely the actual problem text)
-            problem_parts = [p for p in parts if len(p.strip()) > 100]
-            if problem_parts:
-                cleaned = max(problem_parts, key=lambda x: len(x))
-
-        best_match = None
-        best_distance = -1
-        best_index = -1
-
-        for i, question in enumerate(self.questions):
-            question_text = self._get_question_text(question)
-            request_lower = cleaned.lower()
-            question_lower = question_text.lower()
-
-            # Check if question text is contained in the cleaned request
-            if question_lower in request_lower or request_lower in question_lower:
-                debug_log(f"DEBUG: Found substring match at index {i}")
-                return question
-
-            # Exact match
-            if question_lower == request_lower:
-                debug_log(f"DEBUG: Found exact match at index {i}")
-                return question
-
-            # Remove LaTeX formatting for more flexible matching
-            question_no_latex = re.sub(r'\$[^$]+\$', '', question_text)
-            if question_no_latex.lower() == request_lower:
-                debug_log(f"DEBUG: Found match (no LaTeX) at index {i}")
-                return question
-
-            # Calculate Dice coefficient for partial matches
-            # Only consider if request is at least 50% of question length
-            if len(request_lower) >= len(question_lower) * 0.5:
-                distance = dice(question_lower, request_lower)
-
-                if distance > best_distance:
-                    best_distance = distance
-                    best_match = question
-                    best_index = i
-
-        if best_match and best_distance > 0.3:  # Threshold for partial match
-            debug_log(f"DEBUG: Found best partial match at index {best_index} with distance {best_distance:.3f}")
-            return best_match
-
-        debug_log(f"DEBUG: No matching question found for cleaned: {cleaned[:100]}...")
-        return None
-
-    def get_answer(self, question: Dict) -> str:
-        answer = question["answer"]
-        if isinstance(answer, str):
-            normalized = normalize_number(answer)
-            return str(normalized) if normalized is not None else answer
-        return str(answer)
-
-class Simulator:
-    def __init__(
-        self,
-        port: int = 8033,
-        host: str = "localhost",
-        success_rate: float = 0.8,
-        dataset_split: str = "train",
-        dataset_type: str = "aime"
-    ):
-        self.port = port
-        self.host = host
-        self.success_rate = success_rate
-        self.dataset = AimeDataset(dataset_split, dataset_type)
-        self.eval_state = EvalState(
-            id=dataset_type,
-            tasks=[dataset_type],
-            task_states={},
-            sampling_config={"temperature": 0, "max_tokens": 2048}
-        )
-
-    def _generate_response(
-        self,
-        question: Dict,
-        should_be_correct: bool
-    ) -> Dict:
-        expected_answer = self.dataset.get_answer(question)
-
-        if should_be_correct:
-            response_text = expected_answer
-        else:
-            response_text = self._generate_wrong_answer(question)
-
-        comp_tokens = random.randint(10000, 60000)
-        tps_gen = random.uniform(90.0, 110.0)
-        t_gen_ms = comp_tokens / tps_gen * 1000
-
-        return {
-            "id": f"chatcmpl-{int(time.time())}",
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "model": "llama",
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": response_text
-                    },
-                    "finish_reason": "stop"
-                }
-            ],
-            "usage": {
-                "prompt_tokens": 100,
-                "completion_tokens": comp_tokens,
-                "total_tokens": 100 + comp_tokens
-            },
-            "timings": {
-                "predicted_ms": t_gen_ms,
-                "predicted_per_second": tps_gen
-            }
-        }
-
-    def _generate_wrong_answer(self, question: Dict) -> str:
-        expected_answer = self.dataset.get_answer(question)
-
-        if expected_answer.isdigit():
-            wrong_answer = str(int(expected_answer) + 1)
-        else:
-            wrong_answer = expected_answer + " (wrong)"
-
-        return wrong_answer
-
-    def _process_request(self, request_data: Dict) -> Dict:
-        messages = request_data.get("messages", [])
-        if not messages:
-            return {"error": "No messages in request"}
-
-        request_text = messages[0].get("content", "")
-        debug_log(f"DEBUG: Received request with content: {request_text[:150]}...")
-
-        question = self.dataset.find_question(request_text)
-        if not question:
-            debug_log(f"DEBUG: find_question returned None")
-            return {"error": "No matching question found"}
-
-        should_be_correct = random.random() < self.success_rate
-
-        response = self._generate_response(question, should_be_correct)
-
-        task_id = "aime"
-        self.eval_state.task_states[task_id] = {
-            "correct": should_be_correct,
-            "expected": self.dataset.get_answer(question),
-            "predicted": response["choices"][0]["message"]["content"]
-        }
-
-        return response
-
-class RequestHandler(BaseHTTPRequestHandler):
-    def do_GET(self):
-        if self.path == "/v1/models":
-            self._send_json({"data": [{"id": "llama", "object": "model"}]}, 200)
-            return
-        self._send_json({"error": "Not found"}, 404)
-
-    def do_POST(self):
-        if self.path != "/v1/chat/completions":
-            self._send_json({"error": "Not found"}, 404)
-            return
-
-        try:
-            content_length = int(self.headers.get("Content-Length", 0))
-            body = self.rfile.read(content_length)
-            request_data = json.loads(body) if body else None
-
-            if not request_data:
-                self._send_json({"error": "Invalid JSON"}, 400)
-                return
-
-            if simulator is None:
-                self._send_json({"error": "Simulator not initialized"}, 500)
-                return
-
-            response = simulator._process_request(request_data)
-            self._send_json(response, 200)
-
-        except json.JSONDecodeError:
-            self._send_json({"error": "Invalid JSON"}, 400)
-        except Exception as e:
-            print(f"Error processing request: {e}")
-            self._send_json({"error": str(e)}, 500)
-
-    def _send_json(self, data: dict, status: int = 200):
-        body = json.dumps(data).encode("utf-8")
-        self.send_response(status)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Content-Length", str(len(body)))
-        self.end_headers()
-        self.wfile.write(body)
-
-    def log_message(self, format, *args):
-        # Suppress default request logging
-        pass
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="llama-server simulator for testing eval scripts"
-    )
-    parser.add_argument(
-        "--port",
-        type=int,
-        default=8033,
-        help="Server port (default: 8033)"
-    )
-    parser.add_argument(
-        "--host",
-        type=str,
-        default="localhost",
-        help="Server host (default: localhost)"
-    )
-    parser.add_argument(
-        "--success-rate",
-        type=float,
-        default=0.8,
-        help="Success rate 0-1 (default: 0.8)"
-    )
-    parser.add_argument(
-        "--dataset",
-        type=str,
-        default="aime",
-        choices=["aime", "aime2025"],
-        help="Dataset type (default: aime)"
-    )
-    parser.add_argument(
-        "--dataset-split",
-        type=str,
-        default="train",
-        help="AIME dataset split to use (default: train)"
-    )
-
-    args = parser.parse_args()
-
-    global simulator
-    simulator = Simulator(
-        port=args.port,
-        host=args.host,
-        success_rate=args.success_rate,
-        dataset_split=args.dataset_split,
-        dataset_type=args.dataset
-    )
-
-    server = HTTPServer((args.host, args.port), RequestHandler)
-    server_thread = threading.Thread(target=server.serve_forever, daemon=True)
-    server_thread.start()
-
-    print("\n=== llama-server-simulator ===")
-    print(f"Server running on http://{args.host}:{args.port}")
-    print(f"Success rate: {args.success_rate}")
-    print(f"{args.dataset} dataset loaded: {len(simulator.dataset.questions)} questions")
-    print("\nPress Ctrl+C to stop\n")
-
-    try:
-        server_thread.join()
-    except KeyboardInterrupt:
-        print("\nShutting down...")
-        server.shutdown()
-
-if __name__ == "__main__":
-    main()

examples/llama-eval/test-simulator.sh

@@ -1,86 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Get the directory where this script is located
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-echo "=== llama-server-simulator Test Script ==="
-echo ""
-
-PORT=8033
-SUCCESS_RATE=0.8
-TEST_PORT=8034
-
-echo "Starting simulator on port $PORT with success rate $SUCCESS_RATE..."
-source "$SCRIPT_DIR/venv/bin/activate"
-python3 "$SCRIPT_DIR/llama-server-simulator.py" --port $PORT --success-rate $SUCCESS_RATE > /tmp/simulator-test.log 2>&1 &
-SIMULATOR_PID=$!
-
-echo "Waiting for simulator to start..."
-sleep 5
-
-# Helper function to make a request and extract the answer
-make_request() {
-  local question="$1"
-  curl -s -X POST http://localhost:$PORT/v1/chat/completions \
-    -H "Content-Type: application/json" \
-    -d "{
-      \"model\": \"llama\",
-      \"messages\": [
-        {\"role\": \"user\", \"content\": \"$question\"}
-      ],
-      \"temperature\": 0,
-      \"max_tokens\": 2048
-    }" | python3 -c "import sys, json; data = json.load(sys.stdin); print(data.get('choices', [{}])[0].get('message', {}).get('content', data.get('error', 'No response')))"
-}
-
-# Test question (repeated in multiple tests)
-TEST_QUESTION="Quadratic polynomials P(x) and Q(x) have leading coefficients 2 and -2, respectively. The graphs of both polynomials pass through the two points (16,54) and (20,53). Find P(0) + Q(0)."
-
-echo ""
-echo "=== Test 1: Correct Answer ==="
-echo "Sending request with known question..."
-answer=$(make_request "$TEST_QUESTION")
-echo "Answer: $answer"
-echo "Expected: 116"
-echo "Correct: $([ "$answer" == "116" ] && echo "Yes" || echo "No")"
-
-echo ""
-echo "=== Test 2: Wrong Answer ==="
-echo "Sending request with known question (success rate 0.0)..."
-answer=$(make_request "$TEST_QUESTION")
-echo "Answer: $answer"
-echo "Expected: 116"
-echo "Correct: $([ "$answer" == "116" ] && echo "Yes" || echo "No")"
-
-echo ""
-echo "=== Test 3: No Matching Question ==="
-echo "Sending request with non-matching text..."
-response=$(make_request "What is the capital of France?")
-echo "Response: $response"
-echo "Expected: No matching question found"
-echo "Correct: $([ "$response" == "No matching question found" ] && echo "Yes" || echo "No")"
-
-echo ""
-echo "=== Test 4: Success Rate Verification ==="
-echo "Sending 10 requests to test success rate..."
-correct_count=0
-for i in {1..10}; do
-  answer=$(make_request "$TEST_QUESTION")
-  if [ "$answer" == "116" ]; then
-    correct_count=$((correct_count + 1))
-  fi
-  echo "  Request $i: Answer = $answer"
-done
-echo "Correct answers: $correct_count/10"
-echo "Expected: ~8/10 (80% success rate)"
-echo "Success rate: $(echo "scale=1; $correct_count * 10" | bc)%"
-
-echo ""
-echo "=== Test Complete ==="
-echo "Stopping simulator..."
-kill $SIMULATOR_PID 2>/dev/null
-wait $SIMULATOR_PID 2>/dev/null || true
-
-echo "Simulator stopped."

examples/test-cmake/.gitignore

@@ -1,4 +0,0 @@
-llama-build-install
-install
-build
-build-subdir

examples/test-cmake/CMakeLists.txt

@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.14)
-project(llama-simple)
-
-set(CMAKE_CXX_STANDARD 17)
-
-option(LLAMA_TEST_USE_SUBDIR "Use add_subdirectory instead of find_package" OFF)
-
-if(LLAMA_TEST_USE_SUBDIR)
-    add_subdirectory(../../ llama.cpp)
-else()
-    find_package(llama 0.1.0 REQUIRED)
-endif()
-
-add_executable(test-cmake test-cmake.cpp)
-target_link_libraries(test-cmake PRIVATE llama)
-
-if(DEFINED LLAMA_BUILD_NUMBER)
-    target_compile_definitions(test-cmake PRIVATE
-        LLAMA_BUILD_NUMBER=${LLAMA_BUILD_NUMBER}
-        LLAMA_BUILD_COMMIT="${LLAMA_BUILD_COMMIT}"
-    )
-endif()

examples/test-cmake/README.md

@@ -1,45 +0,0 @@
-## cmake-test
-
-This is just for manually testing/developing of a llama.cpp installation to
-enable troubleshooting issues and exploration. The idea is that this can be used
-after making changes to llama.cpp installation cmake configuration and then
-verify it locally.
-
-### find_package
-The following will configure, build, and install llama.cpp, and the build a
-project that uses find_package to use the installation.
-
-Configuring/build/install:
-```console
-./build-install.sh
-```
-The above command will create a directory named `install` in the current directory
-which will have the following files in its lib directory:
-```console
-$ ls install/lib/
-cmake                   libggml.so          libllama-common.so.0      libllama.so.0.1.0  llama.cpp
-libggml-base.so         libggml.so.0        libllama-common.so.0.1.0  libmtmd.so         pkgconfig
-libggml-base.so.0       libggml.so.0.19.0   libllama.so               libmtmd.so.0
-libggml-base.so.0.19.0  libllama-common.so  libllama.so.0             libmtmd.so.0.1.0
-```
-
-Build/run this project using the installation created above:
-```console
-$ ./build.sh
--- Configuring done (0.0s)
--- Generating done (0.0s)
--- Build files have been written to: /path/to/llama.cpp/examples/test-cmake/build
-[100%] Built target test-cmake
-[test-cmake] Using llama.cpp version 0.1.0-dev-b10335
-[test-cmake] Initializing backend...
-load_backend: loaded CPU backend from /path/to/llama.cpp/examples/test-cmake/install/lib/llama.cpp/libggml-cpu-alderlake.so
-[test-cmake] Backend initialized.
-```
-
-### add_subdirectory
-The following will use add_subdirectory to include llama.cpp in a cmake project
-and is intended to simulate projects that build llama.cpp in this way.
-
-```console
-$ USE_SUBDIR=ON ./build.sh
-```

examples/test-cmake/build-install.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-
-set -e
-
-rm -rf llama-build-install install
-
-cmake --fresh -S ../../. -B llama-build-install -DCMAKE_BUILD_TYPE=Release \
-  -DBUILD_SHARED_LIBS=ON \
-  -DGGML_BACKEND_DL=ON \
-  -DGGML_CPU_ALL_VARIANTS=ON \
-  -DLLAMA_TESTS_INSTALL=OFF \
-  -DCMAKE_INSTALL_PREFIX="${PWD}/install" \
-  -DGGML_BACKEND_DIR="${PWD}/install/lib/llama.cpp" \
-  -DGGML_LIB_INSTALL_DIR="${PWD}/install/lib/llama.cpp" \
-  -DLLAMA_LIB_INSTALL_DIR="${PWD}/install/lib/llama.cpp" \
-  -DLLAMA_TOOLS_INSTALL=OFF
-
-cmake --build llama-build-install --parallel 12
-cmake --install llama-build-install

examples/test-cmake/build.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ "${USE_SUBDIR:-OFF}" = "ON" ]; then
-    BUILD_DIR="build-subdir"
-    CMAKE_ARGS="-DLLAMA_TEST_USE_SUBDIR=ON -DLLAMA_BUILD_COMMON=ON -DLLAMA_BUILD_TOOLS=ON -DLLAMA_BUILD_SERVER=ON-DLLAMA_BUILD_TESTS=ON"
-    LIB_PATH="${PWD}/${BUILD_DIR}/bin"
-else
-    BUILD_DIR="build"
-    CMAKE_ARGS="-DCMAKE_PREFIX_PATH=${PWD}/install"
-    LIB_PATH="${PWD}/install/lib/llama.cpp"
-fi
-
-cmake --fresh -S . -B "${BUILD_DIR}" ${CMAKE_ARGS}
-cmake --build "${BUILD_DIR}" -j 8
-
-LD_LIBRARY_PATH="${LIB_PATH}:${PWD}/install/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" "./${BUILD_DIR}/test-cmake"

examples/test-cmake/test-cmake.cpp

@@ -1,17 +0,0 @@
-#include "llama.h"
-#include <cstdio>
-
-int main(void) {
-#ifdef LLAMA_BUILD_NUMBER
-    printf("[test-cmake] llama.cpp version: %s, build: %d (%s)\n",
-           llama_version(), LLAMA_BUILD_NUMBER, LLAMA_BUILD_COMMIT);
-#else
-    printf("[test-cmake] llama.cpp version: %s\n", llama_version());
-#endif
-    printf("[test-cmake] ggml version: %s, commit: %s\n", ggml_version(), ggml_commit());
-    printf("[test-cmake] Initializing backend...\n");
-    llama_backend_init();
-    printf("[test-cmake] Backend initialized.\n");
-    llama_backend_free();
-    return 0;
-}