diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-06-10 15:49:59 +0200 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-06-14 08:27:03 +0200 |
| commit | 7fe02715aac68b958250b43f9d48d641af0a045c (patch) | |
| tree | 7bc866f87999991ef0a3ffa0dd36ce91444e5172 | |
| parent | e8259865f41ceb50dd28b267186d11c62a465135 (diff) | |
| download | ffwd-7fe02715aac68b958250b43f9d48d641af0a045c.tar.gz ffwd-7fe02715aac68b958250b43f9d48d641af0a045c.zip | |
build: export only the public API from the shared library
| -rw-r--r-- | Makefile | 4 | ||||
| -rw-r--r-- | embed.h | 71 | ||||
| -rw-r--r-- | embed_distributed.h | 25 | ||||
| -rw-r--r-- | embed_mlx.h | 63 | ||||
| -rw-r--r-- | embed_server.h | 13 | ||||
| -rw-r--r-- | qwen_kernels.h | 17 | ||||
| -rw-r--r-- | qwen_tokenizer.h | 29 |
7 files changed, 145 insertions, 77 deletions
@@ -3,7 +3,9 @@ CC = gcc # not assume finite math or approximate libm calls: full -ffast-math produced # NaN embeddings on GCC/OpenBLAS Linux builds (-ffinite-math-only and # -fapprox-func are the unsafe parts and stay off). -CFLAGS_BASE = -Wall -Wextra -O3 -march=native -fPIC \ +# -fvisibility=hidden pairs with PPLX_API in the public headers: a new +# public function without the annotation will be missing from the shared lib. +CFLAGS_BASE = -Wall -Wextra -O3 -march=native -fPIC -fvisibility=hidden \ -fno-math-errno -ffp-contract=fast -fno-trapping-math \ -fno-signed-zeros -fassociative-math -freciprocal-math LDFLAGS = -lm -lpthread @@ -7,6 +7,17 @@ #ifndef PPLX_EMBED_H #define PPLX_EMBED_H +/* Public-API export annotation. The libraries are built with + * -fvisibility=hidden, so only declarations carrying PPLX_API are exported + * from the shared library; everything else stays internal. */ +#ifndef PPLX_API +#if defined(__GNUC__) +#define PPLX_API __attribute__((visibility("default"))) +#else +#define PPLX_API +#endif +#endif + #include <stddef.h> #include <stdint.h> @@ -75,7 +86,7 @@ typedef struct { * Reads config.json to determine model size (0.6B vs 4B). * Returns NULL on error. */ -pplx_model_t *pplx_model_load(const char *model_dir); +PPLX_API pplx_model_t *pplx_model_load(const char *model_dir); /* * Load one contiguous transformer layer range for distributed execution. @@ -85,20 +96,20 @@ pplx_model_t *pplx_model_load(const char *model_dir); * loads the final RMSNorm. Safetensors remain mmap-backed, so unselected * weights are not touched. */ -pplx_model_t *pplx_model_load_slice(const char *model_dir, +PPLX_API pplx_model_t *pplx_model_load_slice(const char *model_dir, int layer_start, int layer_end); -void pplx_model_free(pplx_model_t *model); +PPLX_API void pplx_model_free(pplx_model_t *model); /* * Allocate/free mutable scratch buffers for a model. The model must outlive * workspaces created from it. */ -pplx_workspace_t *pplx_workspace_new(const pplx_model_t *model); -void pplx_workspace_free(pplx_workspace_t *ws); +PPLX_API pplx_workspace_t *pplx_workspace_new(const pplx_model_t *model); +PPLX_API void pplx_workspace_free(pplx_workspace_t *ws); /* Config accessor for opaque model ownership. */ -const pplx_config_t *pplx_model_config(const pplx_model_t *model); +PPLX_API const pplx_config_t *pplx_model_config(const pplx_model_t *model); /* * Current mutable workspace memory owned by this workspace, in bytes. @@ -106,7 +117,7 @@ const pplx_config_t *pplx_model_config(const pplx_model_t *model); * This includes the workspace struct, scratch buffers, and RoPE cache capacity. * It does not include immutable mmap'd model weights. */ -size_t pplx_workspace_nbytes(const pplx_workspace_t *ws); +PPLX_API size_t pplx_workspace_nbytes(const pplx_workspace_t *ws); /* * Compute embedding for a token sequence. @@ -122,14 +133,14 @@ size_t pplx_workspace_nbytes(const pplx_workspace_t *ws); * * Returns malloc'd float[hidden_size] (caller frees). NULL on error. */ -float *pplx_model_embed(const pplx_model_t *model, pplx_workspace_t *ws, +PPLX_API float *pplx_model_embed(const pplx_model_t *model, pplx_workspace_t *ws, const int *token_ids, int n_tokens); /* * Compute one embedding into caller-provided out[hidden_size]. * Returns 0 on success, -1 on error. */ -int pplx_model_embed_into(const pplx_model_t *model, pplx_workspace_t *ws, +PPLX_API int pplx_model_embed_into(const pplx_model_t *model, pplx_workspace_t *ws, const int *token_ids, int n_tokens, float *out_embedding); @@ -142,7 +153,7 @@ int pplx_model_embed_into(const pplx_model_t *model, pplx_workspace_t *ws, * * Returns 0 on success, -1 on error. */ -int pplx_model_embed_batch(const pplx_model_t *model, pplx_workspace_t *ws, +PPLX_API int pplx_model_embed_batch(const pplx_model_t *model, pplx_workspace_t *ws, const pplx_input_t *inputs, int batch, float *out_embeddings); @@ -159,7 +170,7 @@ int pplx_model_embed_batch(const pplx_model_t *model, pplx_workspace_t *ws, * * This is the core execution boundary used by layer-sharded inference. */ -int pplx_model_forward_slice_batch(const pplx_model_t *model, +PPLX_API int pplx_model_forward_slice_batch(const pplx_model_t *model, pplx_workspace_t *ws, const pplx_input_t *inputs, int batch, const float *input_states, @@ -173,7 +184,7 @@ int pplx_model_forward_slice_batch(const pplx_model_t *model, * states is [sum(n_tokens), hidden_size]. seq_lengths contains one positive * token count per sequence. The states must already include final RMSNorm. */ -int pplx_pool_batch(const pplx_config_t *cfg, const float *states, +PPLX_API int pplx_pool_batch(const pplx_config_t *cfg, const float *states, const int *seq_lengths, int batch, float *out_embeddings); @@ -185,14 +196,14 @@ int pplx_pool_batch(const pplx_config_t *cfg, const float *states, * Useful for contextual (late-chunking) models where you need * per-token embeddings before splitting by separator positions. */ -float *pplx_model_forward(const pplx_model_t *model, pplx_workspace_t *ws, +PPLX_API float *pplx_model_forward(const pplx_model_t *model, pplx_workspace_t *ws, const int *token_ids, int n_tokens); /* * Run the transformer forward pass into caller-provided * out_states[n_tokens * hidden_size]. Returns 0 on success, -1 on error. */ -int pplx_model_forward_into(const pplx_model_t *model, pplx_workspace_t *ws, +PPLX_API int pplx_model_forward_into(const pplx_model_t *model, pplx_workspace_t *ws, const int *token_ids, int n_tokens, float *out_states); @@ -203,7 +214,7 @@ int pplx_model_forward_into(const pplx_model_t *model, pplx_workspace_t *ws, * pplx_model_forward_into(). Each span is mean pooled into * out_embeddings[n_spans, hidden_size] without L2 normalization. */ -int pplx_pool_spans(const pplx_config_t *cfg, const float *states, int n_tokens, +PPLX_API int pplx_pool_spans(const pplx_config_t *cfg, const float *states, int n_tokens, const pplx_span_t *spans, int n_spans, float *out_embeddings); @@ -211,7 +222,7 @@ int pplx_pool_spans(const pplx_config_t *cfg, const float *states, int n_tokens, * Run one contextual sequence and pool selected token spans. * Returns 0 on success, -1 on error. */ -int pplx_model_embed_spans(const pplx_model_t *model, pplx_workspace_t *ws, +PPLX_API int pplx_model_embed_spans(const pplx_model_t *model, pplx_workspace_t *ws, const int *token_ids, int n_tokens, const pplx_span_t *spans, int n_spans, float *out_embeddings); @@ -222,7 +233,7 @@ int pplx_model_embed_spans(const pplx_model_t *model, pplx_workspace_t *ws, * Documents attend independently, RoPE positions restart for each document, * and out_embeddings contains spans in document order. */ -int pplx_model_embed_spans_batch(const pplx_model_t *model, +PPLX_API int pplx_model_embed_spans_batch(const pplx_model_t *model, pplx_workspace_t *ws, const pplx_context_input_t *inputs, int batch, float *out_embeddings); @@ -233,13 +244,13 @@ int pplx_model_embed_spans_batch(const pplx_model_t *model, * Returns 0 on success. Returns -1 for invalid arguments or a zero-length * vector, which cannot be normalized. */ -int pplx_l2_normalize(float *vec, int dim); +PPLX_API int pplx_l2_normalize(float *vec, int dim); /* * Cosine similarity between two vectors. * Returns 0 for invalid arguments or if either vector has zero length. */ -float pplx_cosine_similarity(const float *a, const float *b, int dim); +PPLX_API float pplx_cosine_similarity(const float *a, const float *b, int dim); /* * Late-interaction model API. @@ -248,21 +259,21 @@ float pplx_cosine_similarity(const float *a, const float *b, int dim); * projected by the snapshot's 1_Dense head and L2-normalized per token by * default, matching ColBERT/MaxSim scoring semantics. */ -pplx_late_model_t *pplx_late_model_load(const char *model_dir); -void pplx_late_model_free(pplx_late_model_t *model); +PPLX_API pplx_late_model_t *pplx_late_model_load(const char *model_dir); +PPLX_API void pplx_late_model_free(pplx_late_model_t *model); -pplx_late_workspace_t *pplx_late_workspace_new(const pplx_late_model_t *model); -void pplx_late_workspace_free(pplx_late_workspace_t *ws); +PPLX_API pplx_late_workspace_t *pplx_late_workspace_new(const pplx_late_model_t *model); +PPLX_API void pplx_late_workspace_free(pplx_late_workspace_t *ws); -const pplx_config_t *pplx_late_model_config(const pplx_late_model_t *model); -int pplx_late_model_token_dim(const pplx_late_model_t *model); +PPLX_API const pplx_config_t *pplx_late_model_config(const pplx_late_model_t *model); +PPLX_API int pplx_late_model_token_dim(const pplx_late_model_t *model); /* * Encode token_ids into out_vectors[n_tokens, token_dim]. * * If normalize is non-zero, every non-zero token vector is L2-normalized. */ -int pplx_late_model_encode_tokens(const pplx_late_model_t *model, +PPLX_API int pplx_late_model_encode_tokens(const pplx_late_model_t *model, pplx_late_workspace_t *ws, const int *token_ids, int n_tokens, int normalize, float *out_vectors); @@ -270,7 +281,7 @@ int pplx_late_model_encode_tokens(const pplx_late_model_t *model, /* * Sum over query tokens of max dot product against document tokens. */ -float pplx_late_maxsim(const float *query_vectors, int query_tokens, +PPLX_API float pplx_late_maxsim(const float *query_vectors, int query_tokens, const float *doc_vectors, int doc_tokens, int dim); @@ -281,13 +292,13 @@ float pplx_late_maxsim(const float *query_vectors, int query_tokens, * doc_vectors[doc_offsets[i] * dim .. doc_offsets[i + 1] * dim). * scores is caller-provided [docs]. */ -int pplx_late_maxsim_batch(const float *query_vectors, int query_tokens, +PPLX_API int pplx_late_maxsim_batch(const float *query_vectors, int query_tokens, const float *doc_vectors, const int *doc_offsets, int docs, int dim, float *scores); /* Verbose level: 0=quiet, 1=info, 2=debug */ -extern int pplx_verbose; -extern int qwen_verbose; +PPLX_API extern int pplx_verbose; +PPLX_API extern int qwen_verbose; #endif /* PPLX_EMBED_H */ diff --git a/embed_distributed.h b/embed_distributed.h index 4cd32e4..3bd3e48 100644 --- a/embed_distributed.h +++ b/embed_distributed.h @@ -5,6 +5,17 @@ #ifndef PPLX_DISTRIBUTED_H #define PPLX_DISTRIBUTED_H +/* Public-API export annotation. The libraries are built with + * -fvisibility=hidden, so only declarations carrying PPLX_API are exported + * from the shared library; everything else stays internal. */ +#ifndef PPLX_API +#if defined(__GNUC__) +#define PPLX_API __attribute__((visibility("default"))) +#else +#define PPLX_API +#endif +#endif + #include "embed.h" typedef struct pplx_dist_client pplx_dist_client_t; @@ -19,17 +30,17 @@ typedef struct { * Open a coordinator-side connection. The coordinator owns layers * [0, local_layer_end); the remote worker must own [local_layer_end, N). */ -pplx_dist_client_t *pplx_dist_client_open(const char *model_dir, +PPLX_API pplx_dist_client_t *pplx_dist_client_open(const char *model_dir, const char *host, int port, int local_layer_end, int use_mlx); -pplx_dist_client_t *pplx_dist_client_open_with_options( +PPLX_API pplx_dist_client_t *pplx_dist_client_open_with_options( const char *model_dir, const char *host, int port, int local_layer_end, int use_mlx, const pplx_dist_options_t *opts); -void pplx_dist_client_free(pplx_dist_client_t *client); +PPLX_API void pplx_dist_client_free(pplx_dist_client_t *client); -const pplx_config_t *pplx_dist_client_config(const pplx_dist_client_t *client); +PPLX_API const pplx_config_t *pplx_dist_client_config(const pplx_dist_client_t *client); -int pplx_dist_client_embed_batch(pplx_dist_client_t *client, +PPLX_API int pplx_dist_client_embed_batch(pplx_dist_client_t *client, const pplx_input_t *inputs, int batch, float *out_embeddings); @@ -37,9 +48,9 @@ int pplx_dist_client_embed_batch(pplx_dist_client_t *client, * Run a final-stage worker until the process is terminated. The worker owns * [layer_start, layer_end), and layer_end must be the model's final layer. */ -int pplx_dist_run_worker(const char *model_dir, const char *host, int port, +PPLX_API int pplx_dist_run_worker(const char *model_dir, const char *host, int port, int layer_start, int layer_end, int use_mlx); -int pplx_dist_run_worker_with_options( +PPLX_API int pplx_dist_run_worker_with_options( const char *model_dir, const char *host, int port, int layer_start, int layer_end, int use_mlx, const pplx_dist_options_t *opts); diff --git a/embed_mlx.h b/embed_mlx.h index 25376e9..52a8801 100644 --- a/embed_mlx.h +++ b/embed_mlx.h @@ -7,6 +7,17 @@ #ifndef PPLX_EMBED_MLX_H #define PPLX_EMBED_MLX_H +/* Public-API export annotation. The libraries are built with + * -fvisibility=hidden, so only declarations carrying PPLX_API are exported + * from the shared library; everything else stays internal. */ +#ifndef PPLX_API +#if defined(__GNUC__) +#define PPLX_API __attribute__((visibility("default"))) +#else +#define PPLX_API +#endif +#endif + #include <stddef.h> #include <stdint.h> #include "embed.h" @@ -25,8 +36,8 @@ typedef struct { * Load model into MLX arrays from safetensors + config.json. * Returns NULL on error. */ -pplx_mlx_ctx_t *pplx_mlx_load(const char *model_dir); -pplx_mlx_ctx_t *pplx_mlx_load_with_options(const char *model_dir, +PPLX_API pplx_mlx_ctx_t *pplx_mlx_load(const char *model_dir); +PPLX_API pplx_mlx_ctx_t *pplx_mlx_load_with_options(const char *model_dir, const pplx_mlx_options_t *opts); /* @@ -34,26 +45,26 @@ pplx_mlx_ctx_t *pplx_mlx_load_with_options(const char *model_dir, * Uses the same half-open range and endpoint ownership rules as * pplx_model_load_slice(). */ -pplx_mlx_ctx_t *pplx_mlx_load_slice(const char *model_dir, +PPLX_API pplx_mlx_ctx_t *pplx_mlx_load_slice(const char *model_dir, int layer_start, int layer_end); -pplx_mlx_ctx_t *pplx_mlx_load_slice_with_options( +PPLX_API pplx_mlx_ctx_t *pplx_mlx_load_slice_with_options( const char *model_dir, int layer_start, int layer_end, const pplx_mlx_options_t *opts); -void pplx_mlx_free(pplx_mlx_ctx_t *ctx); +PPLX_API void pplx_mlx_free(pplx_mlx_ctx_t *ctx); /* * Late-interaction MLX path. This is separate from pooled embeddings because * late snapshots produce one projected token vector per input token for MaxSim * scoring, not one pooled document vector. */ -pplx_mlx_late_ctx_t *pplx_mlx_late_load(const char *model_dir); -pplx_mlx_late_ctx_t *pplx_mlx_late_load_with_options( +PPLX_API pplx_mlx_late_ctx_t *pplx_mlx_late_load(const char *model_dir); +PPLX_API pplx_mlx_late_ctx_t *pplx_mlx_late_load_with_options( const char *model_dir, const pplx_mlx_options_t *opts); -void pplx_mlx_late_free(pplx_mlx_late_ctx_t *ctx); +PPLX_API void pplx_mlx_late_free(pplx_mlx_late_ctx_t *ctx); -const pplx_config_t *pplx_mlx_late_config(const pplx_mlx_late_ctx_t *ctx); -int pplx_mlx_late_token_dim(const pplx_mlx_late_ctx_t *ctx); +PPLX_API const pplx_config_t *pplx_mlx_late_config(const pplx_mlx_late_ctx_t *ctx); +PPLX_API int pplx_mlx_late_token_dim(const pplx_mlx_late_ctx_t *ctx); /* * Encode token_ids into out_vectors[n_tokens, token_dim]. @@ -61,7 +72,7 @@ int pplx_mlx_late_token_dim(const pplx_mlx_late_ctx_t *ctx); * If normalize is non-zero, every token vector is L2-normalized on device * before copying back to CPU memory. */ -int pplx_mlx_late_encode_tokens(pplx_mlx_late_ctx_t *ctx, +PPLX_API int pplx_mlx_late_encode_tokens(pplx_mlx_late_ctx_t *ctx, const int *token_ids, int n_tokens, int normalize, float *out_vectors); @@ -72,21 +83,21 @@ int pplx_mlx_late_encode_tokens(pplx_mlx_late_ctx_t *ctx, * outlive ctx. Copying is optional: MaxSim can consume these handles directly * and copy back only final candidate scores. */ -pplx_mlx_late_vectors_t *pplx_mlx_late_encode_tokens_device( +PPLX_API pplx_mlx_late_vectors_t *pplx_mlx_late_encode_tokens_device( pplx_mlx_late_ctx_t *ctx, const int *token_ids, int n_tokens, int normalize); -void pplx_mlx_late_vectors_free(pplx_mlx_late_vectors_t *vecs); -int pplx_mlx_late_vectors_token_count(const pplx_mlx_late_vectors_t *vecs); -int pplx_mlx_late_vectors_dim(const pplx_mlx_late_vectors_t *vecs); -int pplx_mlx_late_vectors_copy(const pplx_mlx_late_vectors_t *vecs, +PPLX_API void pplx_mlx_late_vectors_free(pplx_mlx_late_vectors_t *vecs); +PPLX_API int pplx_mlx_late_vectors_token_count(const pplx_mlx_late_vectors_t *vecs); +PPLX_API int pplx_mlx_late_vectors_dim(const pplx_mlx_late_vectors_t *vecs); +PPLX_API int pplx_mlx_late_vectors_copy(const pplx_mlx_late_vectors_t *vecs, float *out_vectors); -pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_concat( +PPLX_API pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_concat( pplx_mlx_late_ctx_t *ctx, const pplx_mlx_late_vectors_t *const *items, int count); -pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_select( +PPLX_API pplx_mlx_late_vectors_t *pplx_mlx_late_vectors_select( pplx_mlx_late_ctx_t *ctx, const pplx_mlx_late_vectors_t *vecs, const int *token_indices, int count); -int pplx_mlx_late_maxsim_batch_device( +PPLX_API int pplx_mlx_late_maxsim_batch_device( pplx_mlx_late_ctx_t *ctx, const pplx_mlx_late_vectors_t *query, const pplx_mlx_late_vectors_t *docs, const int *doc_offsets, int docs_count, float *scores); @@ -95,13 +106,13 @@ int pplx_mlx_late_maxsim_batch_device( * Compute embedding for token_ids[0..n_tokens-1]. * Returns malloc'd float[hidden_size] (caller frees). NULL on error. */ -float *pplx_mlx_embed(pplx_mlx_ctx_t *ctx, const int *token_ids, int n_tokens); +PPLX_API float *pplx_mlx_embed(pplx_mlx_ctx_t *ctx, const int *token_ids, int n_tokens); /* * Compute one embedding into caller-provided out[hidden_size]. * Returns 0 on success, -1 on error. */ -int pplx_mlx_embed_into(pplx_mlx_ctx_t *ctx, const int *token_ids, +PPLX_API int pplx_mlx_embed_into(pplx_mlx_ctx_t *ctx, const int *token_ids, int n_tokens, float *out_embedding); /* @@ -111,7 +122,7 @@ int pplx_mlx_embed_into(pplx_mlx_ctx_t *ctx, const int *token_ids, * Padded tokens are masked out of attention keys and mean pooling. * Returns 0 on success, -1 on error. */ -int pplx_mlx_embed_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs, +PPLX_API int pplx_mlx_embed_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs, int batch, float *out_embeddings); /* @@ -120,7 +131,7 @@ int pplx_mlx_embed_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs, * Hidden states cross the API boundary as packed float32 rows even though MLX * executes a padded dense batch internally. */ -int pplx_mlx_forward_slice_batch(pplx_mlx_ctx_t *ctx, +PPLX_API int pplx_mlx_forward_slice_batch(pplx_mlx_ctx_t *ctx, const pplx_input_t *inputs, int batch, const float *input_states, int layer_start, int layer_end, @@ -131,7 +142,7 @@ int pplx_mlx_forward_slice_batch(pplx_mlx_ctx_t *ctx, * Run one contextual sequence and pool selected token spans. * Returns 0 on success, -1 on error. */ -int pplx_mlx_embed_spans(pplx_mlx_ctx_t *ctx, const int *token_ids, +PPLX_API int pplx_mlx_embed_spans(pplx_mlx_ctx_t *ctx, const int *token_ids, int n_tokens, const pplx_span_t *spans, int n_spans, float *out_embeddings); @@ -139,11 +150,11 @@ int pplx_mlx_embed_spans(pplx_mlx_ctx_t *ctx, const int *token_ids, * Run a padded dense contextual document batch and pool every selected span. * out_embeddings contains spans in document order. */ -int pplx_mlx_embed_spans_batch(pplx_mlx_ctx_t *ctx, +PPLX_API int pplx_mlx_embed_spans_batch(pplx_mlx_ctx_t *ctx, const pplx_context_input_t *inputs, int batch, float *out_embeddings); /* Get the config (so embed_cli.c can read hidden_size etc.) */ -const pplx_config_t *pplx_mlx_config(const pplx_mlx_ctx_t *ctx); +PPLX_API const pplx_config_t *pplx_mlx_config(const pplx_mlx_ctx_t *ctx); #endif /* PPLX_EMBED_MLX_H */ diff --git a/embed_server.h b/embed_server.h index c38f0ca..179ed0b 100644 --- a/embed_server.h +++ b/embed_server.h @@ -1,6 +1,17 @@ #ifndef PPLX_SERVER_H #define PPLX_SERVER_H +/* Public-API export annotation. The libraries are built with + * -fvisibility=hidden, so only declarations carrying PPLX_API are exported + * from the shared library; everything else stays internal. */ +#ifndef PPLX_API +#if defined(__GNUC__) +#define PPLX_API __attribute__((visibility("default"))) +#else +#define PPLX_API +#endif +#endif + #include <stdbool.h> typedef struct { @@ -27,6 +38,6 @@ typedef struct { const char *api_key; } pplx_server_config_t; -int pplx_run_server(const pplx_server_config_t *cfg); +PPLX_API int pplx_run_server(const pplx_server_config_t *cfg); #endif diff --git a/qwen_kernels.h b/qwen_kernels.h index fd23c02..9b8156c 100644 --- a/qwen_kernels.h +++ b/qwen_kernels.h @@ -7,6 +7,17 @@ #ifndef QWEN_KERNELS_H #define QWEN_KERNELS_H +/* Public-API export annotation. The libraries are built with + * -fvisibility=hidden, so only declarations carrying PPLX_API are exported + * from the shared library; everything else stays internal. */ +#ifndef PPLX_API +#if defined(__GNUC__) +#define PPLX_API __attribute__((visibility("default"))) +#else +#define PPLX_API +#endif +#endif + #include <stddef.h> #include <stdint.h> @@ -131,12 +142,12 @@ void qwen_apply_rope_neox(float *x, const float *cos_vals, const float *sin_vals /* Set number of threads for parallel operations (default: 1). * Creates a persistent thread pool. Call before inference. */ -void qwen_set_threads(int n); +PPLX_API void qwen_set_threads(int n); /* Get number of available CPU cores */ -int qwen_get_num_cpus(void); +PPLX_API int qwen_get_num_cpus(void); /* Global verbose flag */ -extern int qwen_verbose; +PPLX_API extern int qwen_verbose; #endif /* QWEN_KERNELS_H */ diff --git a/qwen_tokenizer.h b/qwen_tokenizer.h index c698ea3..4c3834c 100644 --- a/qwen_tokenizer.h +++ b/qwen_tokenizer.h @@ -9,6 +9,17 @@ #ifndef QWEN_TOKENIZER_H #define QWEN_TOKENIZER_H +/* Public-API export annotation. The libraries are built with + * -fvisibility=hidden, so only declarations carrying PPLX_API are exported + * from the shared library; everything else stays internal. */ +#ifndef PPLX_API +#if defined(__GNUC__) +#define PPLX_API __attribute__((visibility("default"))) +#else +#define PPLX_API +#endif +#endif + typedef struct { char **id_to_text; /* [vocab_size] decoded text strings */ char **id_to_bpe; /* [vocab_size] raw BPE token strings from vocab.json */ @@ -32,29 +43,29 @@ typedef struct { typedef struct qwen_tokenizer_workspace qwen_tokenizer_workspace_t; /* Load tokenizer from vocab.json in model directory */ -qwen_tokenizer_t *qwen_tokenizer_load(const char *vocab_json_path); +PPLX_API qwen_tokenizer_t *qwen_tokenizer_load(const char *vocab_json_path); /* Decode a single token ID to text. Returns pointer to internal string. */ -const char *qwen_tokenizer_decode(const qwen_tokenizer_t *tok, int token_id); +PPLX_API const char *qwen_tokenizer_decode(const qwen_tokenizer_t *tok, int token_id); /* Look up the id of a raw vocab.json token string (e.g. "<|endoftext|>"). * Returns -1 when the token is not in the vocab. */ -int qwen_tokenizer_token_id(const qwen_tokenizer_t *tok, const char *token); +PPLX_API int qwen_tokenizer_token_id(const qwen_tokenizer_t *tok, const char *token); /* Encode UTF-8 text into token IDs using BPE. * Returns malloc'd array of token IDs and sets *out_n_tokens. * Returns NULL on error (and sets *out_n_tokens to 0). */ -int *qwen_tokenizer_encode(const qwen_tokenizer_t *tok, const char *text, int *out_n_tokens); +PPLX_API int *qwen_tokenizer_encode(const qwen_tokenizer_t *tok, const char *text, int *out_n_tokens); /* Reusable scratch for allocation-light repeated encoding. */ -qwen_tokenizer_workspace_t *qwen_tokenizer_workspace_new(void); -void qwen_tokenizer_workspace_free(qwen_tokenizer_workspace_t *ws); +PPLX_API qwen_tokenizer_workspace_t *qwen_tokenizer_workspace_new(void); +PPLX_API void qwen_tokenizer_workspace_free(qwen_tokenizer_workspace_t *ws); /* Encode into caller-provided out_ids[0..out_cap-1]. * Returns 0 on success, -1 on error, -2 if out_cap is too small. * In all cases *out_n_tokens is set to the number of tokens needed/emitted * when out_n_tokens is non-NULL. */ -int qwen_tokenizer_encode_into(const qwen_tokenizer_t *tok, +PPLX_API int qwen_tokenizer_encode_into(const qwen_tokenizer_t *tok, qwen_tokenizer_workspace_t *ws, const char *text, int *out_ids, int out_cap, @@ -62,12 +73,12 @@ int qwen_tokenizer_encode_into(const qwen_tokenizer_t *tok, /* Same tokenization as qwen_tokenizer_encode(), but reuses ws internally and * performs only the final returned int[] allocation. */ -int *qwen_tokenizer_encode_with_workspace(const qwen_tokenizer_t *tok, +PPLX_API int *qwen_tokenizer_encode_with_workspace(const qwen_tokenizer_t *tok, qwen_tokenizer_workspace_t *ws, const char *text, int *out_n_tokens); /* Free tokenizer */ -void qwen_tokenizer_free(qwen_tokenizer_t *tok); +PPLX_API void qwen_tokenizer_free(qwen_tokenizer_t *tok); #endif /* QWEN_TOKENIZER_H */ |
