view release on metacpan or  search on metacpan

lib/Lugh/Quant.xs  view on Meta::CPAN

OUTPUT:
    RETVAL

int
is_quantized(type)
    int type
CODE:
    if (type < 0 || type >= GGML_TYPE_COUNT) {
        RETVAL = 0;
    } else {
        RETVAL = ggml_is_quantized((enum ggml_type)type) ? 1 : 0;
    }
OUTPUT:
    RETVAL

double
type_sizef(type)
    int type
CODE:
    if (type < 0 || type >= GGML_TYPE_COUNT) {
        croak("Invalid type: %d", type);
    }
    RETVAL = ggml_type_sizef((enum ggml_type)type);
OUTPUT:
    RETVAL

size_t
row_size(type, n_elements)
    int type
    int64_t n_elements
CODE:
    if (type < 0 || type >= GGML_TYPE_COUNT) {
        croak("Invalid type: %d", type);
    }
    RETVAL = ggml_row_size((enum ggml_type)type, n_elements);
OUTPUT:
    RETVAL

int
requires_imatrix(type)
    int type
CODE:
    if (type < 0 || type >= GGML_TYPE_COUNT) {
        croak("Invalid type: %d", type);
    }
    RETVAL = ggml_quantize_requires_imatrix((enum ggml_type)type) ? 1 : 0;
OUTPUT:
    RETVAL

int
type_count()
CODE:
    RETVAL = GGML_TYPE_COUNT;
OUTPUT:
    RETVAL

void
all_types()
PREINIT:
    int i;
PPCODE:
    EXTEND(SP, GGML_TYPE_COUNT);
    for (i = 0; i < GGML_TYPE_COUNT; i++) {
        const char *name = ggml_type_name((enum ggml_type)i);
        if (name && strlen(name) > 0) {
            mPUSHi(i);
        }
    }

void
all_quantized_types()
PREINIT:
    int i;
PPCODE:
    for (i = 0; i < GGML_TYPE_COUNT; i++) {
        if (ggml_is_quantized((enum ggml_type)i)) {
            XPUSHs(sv_2mortal(newSViv(i)));
        }
    }

int
type_from_name(name)
    const char *name
CODE:
    int i;
    RETVAL = -1;
    for (i = 0; i < GGML_TYPE_COUNT; i++) {
        const char *tname = ggml_type_name((enum ggml_type)i);
        if (tname && strEQ(tname, name)) {
            RETVAL = i;
            break;
        }
    }
OUTPUT:
    RETVAL

void
type_info(type)
    int type
PREINIT:
    HV *hv;
    const char *name;
CODE:
    if (type < 0 || type >= GGML_TYPE_COUNT) {
        croak("Invalid type: %d", type);
    }
    
    hv = newHV();
    name = ggml_type_name((enum ggml_type)type);
    
    hv_store(hv, "type", 4, newSViv(type), 0);
    hv_store(hv, "name", 4, newSVpv(name ? name : "unknown", 0), 0);
    hv_store(hv, "size", 4, newSVuv(ggml_type_size((enum ggml_type)type)), 0);
    hv_store(hv, "blck_size", 9, newSViv(ggml_blck_size((enum ggml_type)type)), 0);
    hv_store(hv, "sizef", 5, newSVnv(ggml_type_sizef((enum ggml_type)type)), 0);
    hv_store(hv, "is_quantized", 12, 
             newSViv(ggml_is_quantized((enum ggml_type)type) ? 1 : 0), 0);
    hv_store(hv, "requires_imatrix", 16,
             newSViv(ggml_quantize_requires_imatrix((enum ggml_type)type) ? 1 : 0), 0);
    
    ST(0) = sv_2mortal(newRV_noinc((SV*)hv));
    XSRETURN(1);

BOOT:
{
    dTHX;
    HV *stash = gv_stashpv("Lugh::Quant", GV_ADD);
    AV *export_ok;
    HV *export_tags;
    AV *types_tag;
    AV *funcs_tag;
    
    /* ========================================================================
     * Type Constants