llama_cpp_sys 0.3.2

Automatically-generated bindings to llama.cpp's C API
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

// SPDX-License-Identifier: Apache-2.0

#include "gtest/gtest.h"

#include "kompute/Kompute.hpp"
#include "kompute/logger/Logger.hpp"

#include "shaders/Utils.hpp"

TEST(TestSpecializationConstants, TestTwoConstants)
{
    {
        std::string shader(R"(
          #version 450
          layout (constant_id = 0) const float cOne = 1;
          layout (constant_id = 1) const float cTwo = 1;
          layout (local_size_x = 1) in;
          layout(set = 0, binding = 0) buffer a { float pa[]; };
          layout(set = 0, binding = 1) buffer b { float pb[]; };
          void main() {
              uint index = gl_GlobalInvocationID.x;
              pa[index] = cOne;
              pb[index] = cTwo;
          })");

        std::vector<uint32_t> spirv = compileSource(shader);

        std::shared_ptr<kp::Sequence> sq = nullptr;

        {
            kp::Manager mgr;

            std::shared_ptr<kp::TensorT<float>> tensorA =
              mgr.tensor({ 0, 0, 0 });
            std::shared_ptr<kp::TensorT<float>> tensorB =
              mgr.tensor({ 0, 0, 0 });

            std::vector<std::shared_ptr<kp::Tensor>> params = { tensorA,
                                                                tensorB };

            std::vector<float> spec = std::vector<float>({ 5.0, 0.3 });

            std::shared_ptr<kp::Algorithm> algo =
              mgr.algorithm(params, spirv, {}, spec);

            sq = mgr.sequence()
                   ->record<kp::OpTensorSyncDevice>(params)
                   ->record<kp::OpAlgoDispatch>(algo)
                   ->record<kp::OpTensorSyncLocal>(params)
                   ->eval();

            EXPECT_EQ(tensorA->vector(), std::vector<float>({ 5, 5, 5 }));
            EXPECT_EQ(tensorB->vector(), std::vector<float>({ 0.3, 0.3, 0.3 }));
        }
    }
}

TEST(TestSpecializationConstants, TestConstantsInt)
{
    {
        std::string shader(R"(
          #version 450
          layout (constant_id = 0) const int cOne = 1;
          layout (constant_id = 1) const int cTwo = 1;
          layout (local_size_x = 1) in;
          layout(set = 0, binding = 0) buffer a { int pa[]; };
          layout(set = 0, binding = 1) buffer b { int pb[]; };
          void main() {
              uint index = gl_GlobalInvocationID.x;
              pa[index] = cOne;
              pb[index] = cTwo;
          })");

        std::vector<uint32_t> spirv = compileSource(shader);

        std::shared_ptr<kp::Sequence> sq = nullptr;

        {
            kp::Manager mgr;

            std::shared_ptr<kp::TensorT<int32_t>> tensorA =
              mgr.tensorT<int32_t>({ 0, 0, 0 });
            std::shared_ptr<kp::TensorT<int32_t>> tensorB =
              mgr.tensorT<int32_t>({ 0, 0, 0 });

            std::vector<std::shared_ptr<kp::Tensor>> params = { tensorA,
                                                                tensorB };

            std::vector<int32_t> spec({ -1, -2 });

            std::shared_ptr<kp::Algorithm> algo =
              mgr.algorithm(params, spirv, {}, spec, {});

            sq = mgr.sequence()
                   ->record<kp::OpTensorSyncDevice>(params)
                   ->record<kp::OpAlgoDispatch>(algo)
                   ->record<kp::OpTensorSyncLocal>(params)
                   ->eval();

            EXPECT_EQ(tensorA->vector(), std::vector<int32_t>({ -1, -1, -1 }));
            EXPECT_EQ(tensorB->vector(), std::vector<int32_t>({ -2, -2, -2 }));
        }
    }
}