sipp-sys 0.1.1

Native llama.cpp FFI layer for Sipp
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

#pragma once

#include "decoder.h"

#include <cstdint>
#include <openvino/frontend/node_context.hpp>
#include <string>

namespace ov {
namespace frontend {
namespace ggml {

class TranslateSession;

typedef std::map<std::string, Output<Node>> TensorMap;

class NodeContext : public frontend::NodeContext {
public:
    NodeContext(const std::shared_ptr<GgmlDecoder> & decoder,
                std::shared_ptr<TensorMap> & tensor_map,
                int node_idx,
                TranslateSession * translate_session = nullptr) :
        ov::frontend::NodeContext(decoder->get_op_type(node_idx)),
        m_decoder(decoder),
        m_tensor_map(tensor_map),
        m_node_idx(node_idx),
        m_translate_session(translate_session) {
        m_input_names = decoder->get_input_names(m_node_idx);
        m_output_names = decoder->get_output_names(m_node_idx);
    }

    TranslateSession * get_translate_session() const { return m_translate_session; }

    const std::vector<std::string> & get_input_names() const { return m_input_names; }

    size_t get_input_size() const override { return m_decoder->get_input_size(m_node_idx); }

    ov::element::Type get_input_type(size_t index) const {
        return m_decoder->get_input_type(m_node_idx, m_input_names[index]);
    }

    PartialShape get_input_shape(size_t input_index) const {
        return m_decoder->get_input_shape(m_node_idx, m_input_names[input_index]);
    }

    std::vector<size_t> get_input_stride(size_t index) const {
        return m_decoder->get_input_stride(m_node_idx, m_input_names[index]);
    }

    std::string get_output_name() const { return m_output_names[0]; }

    PartialShape get_output_shape() const { return m_decoder->get_output_shape(m_node_idx); }

    int32_t * get_input_op_params(size_t index) const {
        return m_decoder->get_input_op_params(m_node_idx, m_input_names[index]);
    }

    size_t get_view_input_size(size_t index) const {
        return m_decoder->get_view_input_size(m_node_idx, m_input_names[index]);
    }

    size_t get_view_input_offset(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_offset(m_node_idx, m_input_names[index], view_index);
    }

    size_t get_view_input_src_offset(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_src_offset(m_node_idx, m_input_names[index], view_index);
    }

    std::vector<size_t> get_view_input_stride(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_stride(m_node_idx, m_input_names[index], view_index);
    }

    std::vector<size_t> get_view_input_src_stride(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_src_stride(m_node_idx, m_input_names[index], view_index);
    }

    ov::Shape get_view_input_ggml_shape(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_ggml_shape(m_node_idx, m_input_names[index], view_index);
    }

    ov::Shape get_view_input_src_ggml_shape(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_src_ggml_shape(m_node_idx, m_input_names[index], view_index);
    }

    ov::PartialShape get_view_input_ov_shape(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_ov_shape(m_node_idx, m_input_names[index], view_index);
    }

    ov::PartialShape get_view_input_src_ov_shape(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_src_ov_shape(m_node_idx, m_input_names[index], view_index);
    }

    std::string get_view_input_name(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_name(m_node_idx, m_input_names[index], view_index);
    }

    std::string get_view_input_src_name(size_t index, size_t view_index) const {
        return m_decoder->get_view_input_src_name(m_node_idx, m_input_names[index], view_index);
    }

    int32_t get_op_dynamic_dim() const { return m_decoder->get_op_dynamic_dim(m_node_idx); }

    int32_t * get_output_op_params() const { return m_decoder->get_output_op_params(m_node_idx); }

    size_t get_output_op_offset() const { return m_decoder->get_output_op_offset(m_node_idx); }

    ov::element::Type get_output_type() const { return m_decoder->get_output_type(m_node_idx); }

    std::vector<size_t> get_output_stride() const { return m_decoder->get_output_stride(m_node_idx); }

    Output<Node> get_input(int idx) const override {
        // Check if this input is a VIEW
        size_t view_input_size = m_decoder->get_view_input_size(m_node_idx, m_input_names[idx]);
        if (view_input_size > 0) {
            // This is a VIEW input, get the base tensor name (last element in the chain)
            std::string base_name =
                m_decoder->get_view_input_src_name(m_node_idx, m_input_names[idx], view_input_size - 1);
            // Check if the VIEW has been resolved (translate_view produced a Slice)
            auto view_it = m_tensor_map->find(m_input_names[idx]);
            if (!base_name.empty() && view_it != m_tensor_map->end()) {
                auto base_it = m_tensor_map->find(base_name);
                if (base_it != m_tensor_map->end() &&
                    view_it->second.get_node_shared_ptr() != base_it->second.get_node_shared_ptr()) {
                    return view_it->second;
                }
                return base_it->second;
            }
            if (!base_name.empty()) {
                return m_tensor_map->at(base_name);
            }
        }
        // Not a VIEW or failed to get base name, use the original logic
        return m_tensor_map->at(m_input_names[idx]);
    }

    Output<Node> get_input(const std::string & name) const override {
        if (m_tensor_map->find(name) == m_tensor_map->end()) {
            throw std::runtime_error("'" + name + "' not found in tensor map.");
        }
        return m_tensor_map->at(name);
    }

    bool has_input(const std::string & name) const { return m_tensor_map->find(name) != m_tensor_map->end(); }

    const std::string & get_name() const override { return m_decoder->get_op_name(m_node_idx); }

    ov::Any get_attribute_as_any(const std::string & name) const override { return m_decoder->get_attribute(name); }

    int get_op_case() const { return m_decoder->get_op_case(m_node_idx); }

    bool is_static() const { return m_decoder->is_static(); }

    bool is_stateful() const { return m_decoder->is_stateful(); }

private:
    std::shared_ptr<GgmlDecoder> m_decoder;
    std::shared_ptr<TensorMap> & m_tensor_map;
    int m_node_idx;
    TranslateSession * m_translate_session;
    std::vector<std::string> m_input_names;
    std::vector<std::string> m_output_names;
};

using CreatorFunction = std::function<ov::OutputVector(const ov::frontend::ggml::NodeContext &)>;

}  // namespace ggml
}  // namespace frontend
}  // namespace ov