@fugood/llama.node 0.6.3 → 1.0.0-beta.1

package/src/llama.cpp/tests/test-llama-grammar.cpp

@@ -1,408 +0,0 @@
-#ifdef NDEBUG
-#undef NDEBUG
-#endif
-
-#include "llama.h"
-
-#include "../src/llama-grammar.h"
-
-#include <cassert>
-#include <stdexcept>
-
-int main()
-{
-    llama_grammar_parser parsed_grammar;
-
-    std::vector<std::pair<std::string, uint32_t>> expected = {
-        {"expr", 2},
-        {"expr_6", 6},
-        {"expr_7", 7},
-        {"ident", 8},
-        {"ident_10", 10},
-        {"num", 9},
-        {"num_11", 11},
-        {"root", 0},
-        {"root_1", 1},
-        {"root_5", 5},
-        {"term", 4},
-        {"ws", 3},
-        {"ws_12", 12},
-    };
-
-    std::vector<std::vector<llama_grammar_element>> expected_rules = {
-        {{LLAMA_GRETYPE_RULE_REF, 5}, {LLAMA_GRETYPE_END, 0}},
-        {
-            {LLAMA_GRETYPE_RULE_REF, 2},
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_RULE_REF, 4},
-            {LLAMA_GRETYPE_CHAR, 10},
-            {LLAMA_GRETYPE_END, 0},
-        },
-        {{LLAMA_GRETYPE_RULE_REF, 4}, {LLAMA_GRETYPE_RULE_REF, 7}, {LLAMA_GRETYPE_END, 0}},
-        {{LLAMA_GRETYPE_RULE_REF, 12}, {LLAMA_GRETYPE_END, 0}},
-        {
-            {LLAMA_GRETYPE_RULE_REF, 8},
-            {LLAMA_GRETYPE_ALT, 0},
-            {LLAMA_GRETYPE_RULE_REF, 9},
-            {LLAMA_GRETYPE_ALT, 0},
-            {LLAMA_GRETYPE_CHAR, 40},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_RULE_REF, 2},
-            {LLAMA_GRETYPE_CHAR, 41},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_END, 0},
-        },
-        {{LLAMA_GRETYPE_RULE_REF, 1}, {LLAMA_GRETYPE_RULE_REF, 5}, {LLAMA_GRETYPE_ALT, 0}, {LLAMA_GRETYPE_RULE_REF, 1}, {LLAMA_GRETYPE_END, 0}},
-        {
-            {LLAMA_GRETYPE_CHAR, 45},
-            {LLAMA_GRETYPE_CHAR_ALT, 43},
-            {LLAMA_GRETYPE_CHAR_ALT, 42},
-            {LLAMA_GRETYPE_CHAR_ALT, 47},
-            {LLAMA_GRETYPE_RULE_REF, 4},
-            {LLAMA_GRETYPE_END, 0},
-        },
-        {{LLAMA_GRETYPE_RULE_REF, 6}, {LLAMA_GRETYPE_RULE_REF, 7}, {LLAMA_GRETYPE_ALT, 0}, {LLAMA_GRETYPE_END, 0}},
-        {
-            {LLAMA_GRETYPE_CHAR, 97},
-            {LLAMA_GRETYPE_CHAR_RNG_UPPER, 122},
-            {LLAMA_GRETYPE_RULE_REF, 10},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_END, 0},
-        },
-        {{LLAMA_GRETYPE_RULE_REF, 11}, {LLAMA_GRETYPE_RULE_REF, 3}, {LLAMA_GRETYPE_END, 0}},
-        {
-            {LLAMA_GRETYPE_CHAR, 97},
-            {LLAMA_GRETYPE_CHAR_RNG_UPPER, 122},
-            {LLAMA_GRETYPE_CHAR_ALT, 48},
-            {LLAMA_GRETYPE_CHAR_RNG_UPPER, 57},
-            {LLAMA_GRETYPE_CHAR_ALT, 95},
-            {LLAMA_GRETYPE_RULE_REF, 10},
-            {LLAMA_GRETYPE_ALT, 0},
-            {LLAMA_GRETYPE_END, 0},
-        },
-        {
-            {LLAMA_GRETYPE_CHAR, 48},
-            {LLAMA_GRETYPE_CHAR_RNG_UPPER, 57},
-            {LLAMA_GRETYPE_RULE_REF, 11},
-            {LLAMA_GRETYPE_ALT, 0},
-            {LLAMA_GRETYPE_CHAR, 48},
-            {LLAMA_GRETYPE_CHAR_RNG_UPPER, 57},
-            {LLAMA_GRETYPE_END, 0},
-        },
-        {
-            {LLAMA_GRETYPE_CHAR, 32},
-            {LLAMA_GRETYPE_CHAR_ALT, 9},
-            {LLAMA_GRETYPE_CHAR_ALT, 10},
-            {LLAMA_GRETYPE_RULE_REF, 12},
-            {LLAMA_GRETYPE_ALT, 0},
-            {LLAMA_GRETYPE_END, 0},
-        },
-    };
-
-    for (auto pair : expected)
-    {
-        parsed_grammar.symbol_ids[pair.first] = pair.second;
-    }
-
-    for (auto rule : expected_rules)
-    {
-        parsed_grammar.rules.emplace_back();
-        for (auto element : rule)
-        {
-            parsed_grammar.rules.back().push_back(element);
-        }
-    }
-
-    std::vector<const llama_grammar_element *> grammar_rules(parsed_grammar.c_rules());
-
-    llama_grammar * grammar = llama_grammar_init_impl(nullptr, grammar_rules.data(), grammar_rules.size(), parsed_grammar.symbol_ids.at("root"));
-    if (grammar == nullptr) {
-        throw std::runtime_error("Failed to initialize llama_grammar");
-    }
-
-    std::vector<std::vector<llama_grammar_element>> expected_stacks = {
-        {
-            {LLAMA_GRETYPE_RULE_REF, 5},
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_CHAR, 97},
-        },
-        {
-            {LLAMA_GRETYPE_RULE_REF, 5},
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_CHAR, 48},
-        },
-        {
-            {LLAMA_GRETYPE_RULE_REF, 5},
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_CHAR, 48},
-        },
-        {
-            {LLAMA_GRETYPE_RULE_REF, 5},
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_CHAR, 40},
-        },
-        {
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_CHAR, 97},
-        },
-        {
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_CHAR, 48},
-        },
-        {
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_RULE_REF, 3},
-            {LLAMA_GRETYPE_CHAR, 48},
-        },
-        {
-            {LLAMA_GRETYPE_CHAR, 61},
-            {LLAMA_GRETYPE_RULE_REF, 7},
-            {LLAMA_GRETYPE_CHAR, 40},
-        }};
-
-    auto index = 0;
-    for (const llama_grammar_stack & stack : llama_grammar_get_stacks(grammar))
-    {
-        // compare stack to expected_stack
-        for (uint32_t i = 0; i < stack.size(); i++)
-        {
-            const llama_grammar_element * element = stack[i];
-            const llama_grammar_element & expected_element = expected_stacks[index][i];
-
-            // pretty print error message before asserting
-            if (expected_element.type != element->type || expected_element.value != element->value)
-            {
-                fprintf(stderr, "index: %d\n", index);
-                fprintf(stderr, "expected_element: %d, %u\n", expected_element.type, expected_element.value);
-                fprintf(stderr, "actual_element: %d, %u\n", element->type, element->value);
-                fprintf(stderr, "expected_element != actual_element\n");
-            }
-
-            assert(expected_element.type == element->type && expected_element.value == element->value);
-        }
-        index++;
-    }
-
-    std::vector<llama_grammar_candidate> next_candidates;
-    next_candidates.resize(24);
-
-    for (size_t i = 0; i < 24; ++i)
-    {
-        uint32_t *cp = new uint32_t[2]; // dynamically allocate memory for code_point
-        cp[0] = 37 + i;
-        cp[1] = 0;
-        next_candidates[i] = {i, cp, {}};
-    }
-
-    std::vector<std::vector<std::pair<uint32_t, uint16_t>>> expected_reject = {
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {3, 40},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {11, 48},
-            {12, 49},
-            {13, 50},
-            {14, 51},
-            {15, 52},
-            {16, 53},
-            {17, 54},
-            {18, 55},
-            {19, 56},
-            {20, 57},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {3, 40},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {3, 40},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {11, 48},
-            {12, 49},
-            {13, 50},
-            {14, 51},
-            {15, 52},
-            {16, 53},
-            {17, 54},
-            {18, 55},
-            {19, 56},
-            {20, 57},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {3, 40},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {11, 48},
-            {12, 49},
-            {13, 50},
-            {14, 51},
-            {15, 52},
-            {16, 53},
-            {17, 54},
-            {18, 55},
-            {19, 56},
-            {20, 57},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {3, 40},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {3, 40},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-        {
-            {0, 37},
-            {1, 38},
-            {2, 39},
-            {4, 41},
-            {5, 42},
-            {6, 43},
-            {7, 44},
-            {8, 45},
-            {9, 46},
-            {10, 47},
-            {11, 48},
-            {12, 49},
-            {13, 50},
-            {14, 51},
-            {15, 52},
-            {16, 53},
-            {17, 54},
-            {18, 55},
-            {19, 56},
-            {20, 57},
-            {21, 58},
-            {22, 59},
-            {23, 60},
-        },
-    };
-
-    std::vector<llama_grammar_candidate> rejects = llama_grammar_reject_candidates_for_stack(llama_grammar_get_rules(grammar), llama_grammar_get_stacks(grammar)[0], next_candidates);
-
-    std::vector<std::vector<llama_grammar_candidate>> all_rejects;
-
-    for (std::size_t count = 0; count < llama_grammar_get_stacks(grammar).size(); ++count)
-    {
-        rejects = llama_grammar_reject_candidates_for_stack(llama_grammar_get_rules(grammar), llama_grammar_get_stacks(grammar)[count], next_candidates);
-        all_rejects.push_back(rejects);
-    }
-
-    index = 0;
-    for (auto rej : all_rejects)
-    {
-        for (uint32_t i = 0; i < rej.size(); i++)
-        {
-            auto element = rej[i];
-            auto expected_element = expected_reject[index][i];
-            assert(element.index == expected_element.first && *element.code_points == expected_element.second);
-        }
-        index++;
-    }
-
-    for (auto &candidate : next_candidates)
-    {
-        delete[] candidate.code_points;
-        candidate.code_points = nullptr;
-    }
-
-    llama_grammar_free_impl(grammar);
-
-    return 0;
-}

package/src/llama.cpp/tests/test-log.cpp

@@ -1,39 +0,0 @@
-#include "log.h"
-
-#include <cstdlib>
-#include <thread>
-
-int main() {
-    const int n_thread = 8;
-
-    std::thread threads[n_thread];
-    for (int i = 0; i < n_thread; i++) {
-        threads[i] = std::thread([i]() {
-            const int n_msg = 1000;
-
-            for (int j = 0; j < n_msg; j++) {
-                const int log_type = std::rand() % 4;
-
-                switch (log_type) {
-                    case 0: LOG_INF("Thread %d: %d\n", i, j); break;
-                    case 1: LOG_WRN("Thread %d: %d\n", i, j); break;
-                    case 2: LOG_ERR("Thread %d: %d\n", i, j); break;
-                    case 3: LOG_DBG("Thread %d: %d\n", i, j); break;
-                    default:
-                        break;
-                }
-
-                if (rand () % 10 < 5) {
-                    common_log_set_timestamps(common_log_main(), rand() % 2);
-                    common_log_set_prefix    (common_log_main(), rand() % 2);
-                }
-            }
-        });
-    }
-
-    for (int i = 0; i < n_thread; i++) {
-        threads[i].join();
-    }
-
-    return 0;
-}

package/src/llama.cpp/tests/test-model-load-cancel.cpp

@@ -1,27 +0,0 @@
-#include "llama.h"
-#include "get-model.h"
-
-#include <cstdlib>
-
-int main(int argc, char *argv[] ) {
-    auto * model_path = get_model_or_exit(argc, argv);
-    auto * file = fopen(model_path, "r");
-    if (file == nullptr) {
-        fprintf(stderr, "no model at '%s' found\n", model_path);
-        return EXIT_FAILURE;
-    }
-
-    fprintf(stderr, "using '%s'\n", model_path);
-    fclose(file);
-
-    llama_backend_init();
-    auto params = llama_model_params{};
-    params.use_mmap = false;
-    params.progress_callback = [](float progress, void * ctx){
-        (void) ctx;
-        return progress > 0.50;
-    };
-    auto * model = llama_model_load_from_file(model_path, params);
-    llama_backend_free();
-    return model == nullptr ? EXIT_SUCCESS : EXIT_FAILURE;
-}

package/src/llama.cpp/tests/test-mtmd-c-api.c

@@ -1,63 +0,0 @@
-#include <stdio.h>
-#include <assert.h>
-
-#include "mtmd.h"
-
-int main(void) {
-    printf("\n\nTesting libmtmd C API...\n");
-    printf("--------\n\n");
-
-    struct mtmd_context_params params = mtmd_context_params_default();
-    printf("Default image marker: %s\n", params.image_marker);
-
-    mtmd_input_chunks * chunks = mtmd_test_create_input_chunks();
-
-    if (!chunks) {
-        fprintf(stderr, "Failed to create input chunks\n");
-        return 1;
-    }
-
-    size_t n_chunks = mtmd_input_chunks_size(chunks);
-    printf("Number of chunks: %zu\n", n_chunks);
-    assert(n_chunks > 0);
-
-    for (size_t i = 0; i < n_chunks; i++) {
-        const mtmd_input_chunk * chunk = mtmd_input_chunks_get(chunks, i);
-        assert(chunk != NULL);
-        enum mtmd_input_chunk_type type = mtmd_input_chunk_get_type(chunk);
-        printf("Chunk %zu type: %d\n", i, type);
-
-        if (type == MTMD_INPUT_CHUNK_TYPE_TEXT) {
-            size_t n_tokens;
-            const llama_token * tokens = mtmd_input_chunk_get_tokens_text(chunk, &n_tokens);
-            printf("    Text chunk with %zu tokens\n", n_tokens);
-            assert(tokens != NULL);
-            assert(n_tokens > 0);
-            for (size_t j = 0; j < n_tokens; j++) {
-                assert(tokens[j] >= 0);
-                printf("    > Token %zu: %d\n", j, tokens[j]);
-            }
-
-        } else if (type == MTMD_INPUT_CHUNK_TYPE_IMAGE) {
-            const mtmd_image_tokens * image_tokens = mtmd_input_chunk_get_tokens_image(chunk);
-            size_t n_tokens = mtmd_image_tokens_get_n_tokens(image_tokens);
-            size_t nx = mtmd_image_tokens_get_nx(image_tokens);
-            size_t ny = mtmd_image_tokens_get_ny(image_tokens);
-            const char * id = mtmd_image_tokens_get_id(image_tokens);
-            assert(n_tokens > 0);
-            assert(nx > 0);
-            assert(ny > 0);
-            assert(id != NULL);
-            printf("    Image chunk with %zu tokens\n", n_tokens);
-            printf("    Image size: %zu x %zu\n", nx, ny);
-            printf("    Image ID: %s\n", id);
-        }
-    }
-
-    // Free the chunks
-    mtmd_input_chunks_free(chunks);
-
-    printf("\n\nDONE: test libmtmd C API...\n");
-
-    return 0;
-}