ollama

1
#include "dyn_ext_server.h"
2

3
#include <stdio.h>
4
#include <string.h>
5

6
#ifdef __linux__
7
#include <dlfcn.h>
8
#define LOAD_LIBRARY(lib, flags) dlopen(lib, flags)
9
#define LOAD_SYMBOL(handle, sym) dlsym(handle, sym)
10
#define LOAD_ERR() strdup(dlerror())
11
#define UNLOAD_LIBRARY(handle) dlclose(handle)
12
#elif _WIN32
13
#include <windows.h>
14
#define LOAD_LIBRARY(lib, flags) LoadLibrary(lib)
15
#define LOAD_SYMBOL(handle, sym) GetProcAddress(handle, sym)
16
#define UNLOAD_LIBRARY(handle) FreeLibrary(handle)
17
inline char *LOAD_ERR() {
18
  LPSTR messageBuffer = NULL;
19
  size_t size = FormatMessageA(
20
      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
21
          FORMAT_MESSAGE_IGNORE_INSERTS,
22
      NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
23
      (LPSTR)&messageBuffer, 0, NULL);
24
  char *resp = strdup(messageBuffer);
25
  LocalFree(messageBuffer);
26
  return resp;
27
}
28
#else
29
#include <dlfcn.h>
30
#define LOAD_LIBRARY(lib, flags) dlopen(lib, flags)
31
#define LOAD_SYMBOL(handle, sym) dlsym(handle, sym)
32
#define LOAD_ERR() strdup(dlerror())
33
#define UNLOAD_LIBRARY(handle) dlclose(handle)
34
#endif
35

36
void dyn_init(const char *libPath, struct dynamic_llama_server *s,
37
                       ext_server_resp_t *err) {
38
  int i = 0;
39
  struct lookup {
40
    char *s;
41
    void **p;
42
  } l[] = {
43
      {"llama_server_init", (void *)&s->llama_server_init},
44
      {"llama_server_start", (void *)&s->llama_server_start},
45
      {"llama_server_stop", (void *)&s->llama_server_stop},
46
      {"llama_server_completion", (void *)&s->llama_server_completion},
47
      {"llama_server_completion_next_result",
48
       (void *)&s->llama_server_completion_next_result},
49
      {"llama_server_completion_cancel",
50
       (void *)&s->llama_server_completion_cancel},
51
      {"llama_server_release_task_result",
52
       (void *)&s->llama_server_release_task_result},
53
      {"llama_server_tokenize", (void *)&s->llama_server_tokenize},
54
      {"llama_server_detokenize", (void *)&s->llama_server_detokenize},
55
      {"llama_server_embedding", (void *)&s->llama_server_embedding},
56
      {"llama_server_release_json_resp",
57
       (void *)&s->llama_server_release_json_resp},
58
      {"", NULL},
59
  };
60

61
  printf("loading library %s\n", libPath);
62
  s->handle = LOAD_LIBRARY(libPath, RTLD_LOCAL|RTLD_NOW);
63
  if (!s->handle) {
64
    err->id = -1;
65
    char *msg = LOAD_ERR();
66
    snprintf(err->msg, err->msg_len,
67
             "Unable to load dynamic server library: %s", msg);
68
    free(msg);
69
    return;
70
  }
71

72
  for (i = 0; l[i].p != NULL; i++) {
73
    *l[i].p = LOAD_SYMBOL(s->handle, l[i].s);
74
    if (!l[i].p) {
75
      UNLOAD_LIBRARY(s->handle);
76
      err->id = -1;
77
      char *msg = LOAD_ERR();
78
      snprintf(err->msg, err->msg_len, "symbol lookup for %s failed: %s",
79
               l[i].s, msg);
80
      free(msg);
81
      return;
82
    }
83
  }
84
}
85

86
inline void dyn_llama_server_init(struct dynamic_llama_server s,
87
                                           ext_server_params_t *sparams,
88
                                           ext_server_resp_t *err) {
89
  s.llama_server_init(sparams, err);
90
}
91

92
inline void dyn_llama_server_start(struct dynamic_llama_server s) {
93
  s.llama_server_start();
94
}
95

96
inline void dyn_llama_server_stop(struct dynamic_llama_server s) {
97
  s.llama_server_stop();
98
}
99

100
inline void dyn_llama_server_completion(struct dynamic_llama_server s,
101
                                                 const char *json_req,
102
                                                 ext_server_resp_t *resp) {
103
  s.llama_server_completion(json_req, resp);
104
}
105

106
inline void dyn_llama_server_completion_next_result(
107
    struct dynamic_llama_server s, const int task_id,
108
    ext_server_task_result_t *result) {
109
  s.llama_server_completion_next_result(task_id, result);
110
}
111

112
inline void dyn_llama_server_completion_cancel(
113
    struct dynamic_llama_server s, const int task_id, ext_server_resp_t *err) {
114
  s.llama_server_completion_cancel(task_id, err);
115
}
116
inline void dyn_llama_server_release_task_result(
117
    struct dynamic_llama_server s, ext_server_task_result_t *result) {
118
  s.llama_server_release_task_result(result);
119
}
120

121
inline void dyn_llama_server_tokenize(struct dynamic_llama_server s,
122
                                               const char *json_req,
123
                                               char **json_resp,
124
                                               ext_server_resp_t *err) {
125
  s.llama_server_tokenize(json_req, json_resp, err);
126
}
127

128
inline void dyn_llama_server_detokenize(struct dynamic_llama_server s,
129
                                                 const char *json_req,
130
                                                 char **json_resp,
131
                                                 ext_server_resp_t *err) {
132
  s.llama_server_detokenize(json_req, json_resp, err);
133
}
134

135
inline void dyn_llama_server_embedding(struct dynamic_llama_server s,
136
                                                const char *json_req,
137
                                                char **json_resp,
138
                                                ext_server_resp_t *err) {
139
  s.llama_server_embedding(json_req, json_resp, err);
140
}
141

142
inline void dyn_llama_server_release_json_resp(
143
    struct dynamic_llama_server s, char **json_resp) {
144
  s.llama_server_release_json_resp(json_resp);
145
}
146