llama-cpp-sys-4 0.2.46

Low Level Bindings to llama.cpp
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

#ifndef OP_DESC_H
#define OP_DESC_H

#define GGML_COMMON_IMPL_CPP
#include "ggml-backend-impl.h"
#include "ggml-common.h"

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

struct op_desc {
    char strides[64 * GGML_MAX_SRC];
    char dims[64 * GGML_MAX_SRC];
    char types[16 * GGML_MAX_SRC];
    char buffs[64 * GGML_MAX_SRC];
    char names[64 * GGML_MAX_SRC];

    int format_tensor_dims(char * str, const struct ggml_tensor * t) {
        if (t->ne[2] == 1 && t->ne[3] == 1) {
            return sprintf(str, "%d:%d", (int) t->ne[0], (int) t->ne[1]);
        } else {
            return sprintf(str, "%d:%d:%d:%d", (int) t->ne[0], (int) t->ne[1], (int) t->ne[2], (int) t->ne[3]);
        }
    }

    void format_op_dims(char * str, const struct ggml_tensor * t) {
        char * p = str;

        // append src0 and src1 (if any)
        if (t->src[0]) {
            p += format_tensor_dims(p, t->src[0]);

            for (int i = 1; i < GGML_MAX_SRC && t->src[i]; i++) {
                p += sprintf(p, " x ");
                p += format_tensor_dims(p, t->src[i]);
            }

            p += sprintf(p, " -> ");
        }

        // format self dims separately for better visual alignment
        char self[64];
        format_tensor_dims(self, t);

        p += sprintf(p, "%s", self);
    }

    int format_tensor_strides(char * str, const struct ggml_tensor * t) {
        const char * c = ggml_is_contiguous(t) ? "" : "!";

        if (t->ne[2] == 1 && t->ne[3] == 1) {
            return sprintf(str, "%zu:%zu%s", (size_t) t->nb[0], (size_t) t->nb[1], c);
        } else {
            return sprintf(str, "%zu:%zu:%zu:%zu%s", (size_t) t->nb[0], (size_t) t->nb[1], (size_t) t->nb[2], (size_t) t->nb[3], c);
        }
    }

    void format_op_strides(char * str, const struct ggml_tensor * t) {
        char * p = str;

        // append src0 and src1 (if any)
        if (t->src[0]) {
            p += format_tensor_strides(p, t->src[0]);

            for (int i = 1; i < GGML_MAX_SRC && t->src[i]; i++) {
                p += sprintf(p, " x ");
                p += format_tensor_strides(p, t->src[i]);
            }

            p += sprintf(p, " -> ");
        }

        // format self dims separately for better visual alignment
        char self[64];
        format_tensor_strides(self, t);

        p += sprintf(p, "%s", self);
    }

    void format_op_types(char * str, const struct ggml_tensor * t) {
        char * p = str;

        // append src0 and src1 (if any)
        if (t->src[0]) {
            p += sprintf(p, "%s", ggml_type_name(t->src[0]->type));

            for (int i = 1; i < GGML_MAX_SRC && t->src[i]; i++) {
                p += sprintf(p, " x ");
                p += sprintf(p, "%s", ggml_type_name(t->src[i]->type));
            }

            p += sprintf(p, " -> ");
        }

        p += sprintf(p, "%s", ggml_type_name(t->type));
    }

    const char * tensor_buff_name(const struct ggml_tensor * t) {
        if (t->buffer) {
            return ggml_backend_buffer_name(t->buffer);
        }
        return "NONE";
    }

    void format_op_buffs(char * str, const struct ggml_tensor * t) {
        char * p = str;

        // append src0 and src1 (if any)
        if (t->src[0]) {
            p += sprintf(p, "%s", tensor_buff_name(t->src[0]));

            for (int i = 1; i < GGML_MAX_SRC && t->src[i]; i++) {
                p += sprintf(p, " x ");
                p += sprintf(p, "%s", tensor_buff_name(t->src[i]));
            }

            p += sprintf(p, " -> ");
        }

        p += sprintf(p, "%s", tensor_buff_name(t));
    }

    void format_op_names(char * str, const struct ggml_tensor * t) {
        char * p = str;

        // append src0 and src1 (if any)
        if (t->src[0]) {
            p += sprintf(p, "%s", t->src[0]->name);

            for (int i = 1; i < GGML_MAX_SRC && t->src[i]; i++) {
                p += sprintf(p, " x ");
                p += sprintf(p, "%s", t->src[i]->name);
            }

            p += sprintf(p, " -> ");
        }

        p += sprintf(p, "%s", t->name);
    }

    void format(const ggml_tensor * op) {
        format_op_dims(dims, op);
        format_op_strides(strides, op);
        format_op_types(types, op);
        format_op_buffs(buffs, op);
        format_op_names(names, op);
    }

    op_desc() {}
    op_desc(const ggml_tensor * op) { format(op); }
};

#endif // OP_DESC_H