Skip to content

Commit 01dd1ee

Browse files
afonso360afonso360
committed
Add support for RVV feature detection
1 parent d8f15d9 commit 01dd1ee

3 files changed

Lines changed: 231 additions & 1 deletion

File tree

‎src/distance-cpu.c‎

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717
#include "distance-sse2.h"
1818
#include "distance-avx2.h"
1919
#include "distance-avx512.h"
20+
#include "distance-rvv.h"
2021

2122
const char *distance_backend_name = "CPU";
2223
distance_function_t dispatch_distance_table[VECTOR_DISTANCE_MAX][VECTOR_TYPE_MAX] = {0};
@@ -828,7 +829,14 @@ float bit1_distance_hamming_cpu (const void *v1, const void *v2, int n) {
828829
x86_cpuid(1, 0, &eax, &ebx, &ecx, &edx);
829830
return (edx & (1 << 26)) != 0; // SSE2
830831
}
831-
832+
#elif defined(__riscv) || defined(__riscv__)
833+
#include <sys/auxv.h>
834+
#define ISA_V_HWCAP (1 << ('v' - 'a'))
835+
836+
bool cpu_supports_rvv (void) {
837+
unsigned long hw_cap = getauxval(AT_HWCAP);
838+
return (hw_cap & ISA_V_HWCAP) != 0;
839+
}
832840
#else
833841
// For ARM (NEON is always present on aarch64, runtime detection rarely needed)
834842
#if defined(__aarch64__) || defined(__ARM_NEON) || defined(__ARM_NEON__)
@@ -919,6 +927,12 @@ void init_distance_functions (bool force_cpu) {
919927
if (cpu_supports_neon()) {
920928
init_distance_functions_neon();
921929
}
930+
#elif defined(__riscv) || defined(__riscv__)
931+
printf("RISC-V detected\n");
932+
if (cpu_supports_rvv()) {
933+
printf("RISC-V RVV detected\n");
934+
init_distance_functions_rvv();
935+
}
922936
#endif
923937
}
924938

‎src/distance-rvv.c‎

Lines changed: 201 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,201 @@
1+
//
2+
// distance-rvv.c
3+
// sqlitevector
4+
//
5+
// Created by Afonso Bordado on 2026/02/19.
6+
//
7+
8+
9+
#include "distance-rvv.h"
10+
#include "distance-cpu.h"
11+
12+
#if defined(__riscv_vector)
13+
#include <riscv_vector.h>
14+
15+
extern distance_function_t dispatch_distance_table[VECTOR_DISTANCE_MAX][VECTOR_TYPE_MAX];
16+
extern const char *distance_backend_name;
17+
18+
// MARK: - FLOAT32 -
19+
20+
float float32_distance_l2_rvv (const void *v1, const void *v2, int n) {
21+
panic("float32_distance_l2_rvv: unimplemented");
22+
return 0.0f;
23+
}
24+
25+
float float32_distance_l2_squared_rvv (const void *v1, const void *v2, int n) {
26+
panic("float32_distance_l2_squared_rvv: unimplemented");
27+
return 0.0f;
28+
}
29+
30+
float float32_distance_l1_rvv (const void *v1, const void *v2, int n) {
31+
panic("float32_distance_l1_rvv: unimplemented");
32+
return 0.0f;
33+
}
34+
35+
float float32_distance_dot_rvv (const void *v1, const void *v2, int n) {
36+
panic("float32_distance_dot_rvv: unimplemented");
37+
return 0.0f;
38+
}
39+
40+
float float32_distance_cosine_rvv (const void *v1, const void *v2, int n) {
41+
panic("float32_distance_cosine_rvv: unimplemented");
42+
return 0.0f;
43+
}
44+
45+
46+
// MARK: - FLOAT16 -
47+
48+
float float16_distance_l2_rvv (const void *v1, const void *v2, int n) {
49+
panic("float16_distance_l2_rvv: unimplemented");
50+
return 0.0f;
51+
}
52+
53+
float float16_distance_l2_squared_rvv (const void *v1, const void *v2, int n) {
54+
panic("float16_distance_l2_squared_rvv: unimplemented");
55+
return 0.0f;
56+
}
57+
58+
float float16_distance_l1_rvv (const void *v1, const void *v2, int n) {
59+
panic("float16_distance_l1_rvv: unimplemented");
60+
return 0.0f;
61+
}
62+
63+
float float16_distance_dot_rvv (const void *v1, const void *v2, int n) {
64+
panic("float16_distance_dot_rvv: unimplemented");
65+
return 0.0f;
66+
}
67+
68+
float float16_distance_cosine_rvv (const void *v1, const void *v2, int n) {
69+
panic("float16_distance_cosine_rvv: unimplemented");
70+
return 0.0f;
71+
}
72+
73+
// MARK: - BFLOAT16 -
74+
75+
float bfloat16_distance_l2_rvv (const void *v1, const void *v2, int n) {
76+
panic("bfloat16_distance_l2_rvv: unimplemented");
77+
return 0.0f;
78+
}
79+
80+
float bfloat16_distance_l2_squared_rvv (const void *v1, const void *v2, int n) {
81+
panic("bfloat16_distance_l2_squared_rvv: unimplemented");
82+
return 0.0f;
83+
}
84+
85+
float bfloat16_distance_l1_rvv (const void *v1, const void *v2, int n) {
86+
panic("bfloat16_distance_l1_rvv: unimplemented");
87+
return 0.0f;
88+
}
89+
90+
float bfloat16_distance_dot_rvv (const void *v1, const void *v2, int n) {
91+
panic("bfloat16_distance_dot_rvv: unimplemented");
92+
return 0.0f;
93+
}
94+
95+
float bfloat16_distance_cosine_rvv (const void *v1, const void *v2, int n) {
96+
panic("bfloat16_distance_cosine_rvv: unimplemented");
97+
return 0.0f;
98+
}
99+
100+
// MARK: - UINT8 -
101+
102+
float uint8_distance_l2_rvv (const void *v1, const void *v2, int n) {
103+
panic("uint8_distance_l2_rvv: unimplemented");
104+
return 0.0f;
105+
}
106+
107+
float uint8_distance_l2_squared_rvv (const void *v1, const void *v2, int n) {
108+
panic("uint8_distance_l2_squared_rvv: unimplemented");
109+
return 0.0f;
110+
}
111+
112+
float uint8_distance_dot_rvv (const void *v1, const void *v2, int n) {
113+
panic("uint8_distance_dot_rvv: unimplemented");
114+
return 0.0f;
115+
}
116+
117+
float uint8_distance_l1_rvv (const void *v1, const void *v2, int n) {
118+
panic("uint8_distance_l1_rvv: unimplemented");
119+
return 0.0f;
120+
}
121+
122+
float uint8_distance_cosine_rvv (const void *v1, const void *v2, int n) {
123+
panic("uint8_distance_cosine_rvv: unimplemented");
124+
return 0.0f;
125+
}
126+
127+
// MARK: - INT8 -
128+
129+
float int8_distance_l2_rvv (const void *v1, const void *v2, int n) {
130+
panic("int8_distance_l2_rvv: unimplemented");
131+
return 0.0f;
132+
}
133+
134+
float int8_distance_l2_squared_rvv (const void *v1, const void *v2, int n) {
135+
panic("int8_distance_l2_squared_rvv: unimplemented");
136+
return 0.0f;
137+
}
138+
139+
float int8_distance_dot_rvv (const void *v1, const void *v2, int n) {
140+
panic("int8_distance_dot_rvv: unimplemented");
141+
return 0.0f;
142+
}
143+
144+
float int8_distance_l1_rvv (const void *v1, const void *v2, int n) {
145+
panic("int8_distance_l1_rvv: unimplemented");
146+
return 0.0f;
147+
}
148+
149+
float int8_distance_cosine_rvv (const void *v1, const void *v2, int n) {
150+
panic("int8_distance_cosine_rvv: unimplemented");
151+
return 0.0f;
152+
}
153+
154+
// MARK: - BIT -
155+
156+
float bit1_distance_hamming_rvv (const void *v1, const void *v2, int n) {
157+
panic("bit1_distance_hamming_rvv: unimplemented");
158+
return 0.0f;
159+
}
160+
161+
#endif
162+
163+
// MARK: -
164+
165+
void init_distance_functions_rvv (void) {
166+
#if defined(__riscv_vector)
167+
dispatch_distance_table[VECTOR_DISTANCE_L2][VECTOR_TYPE_F32] = float32_distance_l2_rvv;
168+
dispatch_distance_table[VECTOR_DISTANCE_L2][VECTOR_TYPE_F16] = float16_distance_l2_rvv;
169+
dispatch_distance_table[VECTOR_DISTANCE_L2][VECTOR_TYPE_BF16] = bfloat16_distance_l2_rvv;
170+
dispatch_distance_table[VECTOR_DISTANCE_L2][VECTOR_TYPE_U8] = uint8_distance_l2_rvv;
171+
dispatch_distance_table[VECTOR_DISTANCE_L2][VECTOR_TYPE_I8] = int8_distance_l2_rvv;
172+
173+
dispatch_distance_table[VECTOR_DISTANCE_SQUARED_L2][VECTOR_TYPE_F32] = float32_distance_l2_squared_rvv;
174+
dispatch_distance_table[VECTOR_DISTANCE_SQUARED_L2][VECTOR_TYPE_F16] = float16_distance_l2_squared_rvv;
175+
dispatch_distance_table[VECTOR_DISTANCE_SQUARED_L2][VECTOR_TYPE_BF16] = bfloat16_distance_l2_squared_rvv;
176+
dispatch_distance_table[VECTOR_DISTANCE_SQUARED_L2][VECTOR_TYPE_U8] = uint8_distance_l2_squared_rvv;
177+
dispatch_distance_table[VECTOR_DISTANCE_SQUARED_L2][VECTOR_TYPE_I8] = int8_distance_l2_squared_rvv;
178+
179+
dispatch_distance_table[VECTOR_DISTANCE_COSINE][VECTOR_TYPE_F32] = float32_distance_cosine_rvv;
180+
dispatch_distance_table[VECTOR_DISTANCE_COSINE][VECTOR_TYPE_F16] = float16_distance_cosine_rvv;
181+
dispatch_distance_table[VECTOR_DISTANCE_COSINE][VECTOR_TYPE_BF16] = bfloat16_distance_cosine_rvv;
182+
dispatch_distance_table[VECTOR_DISTANCE_COSINE][VECTOR_TYPE_U8] = uint8_distance_cosine_rvv;
183+
dispatch_distance_table[VECTOR_DISTANCE_COSINE][VECTOR_TYPE_I8] = int8_distance_cosine_rvv;
184+
185+
dispatch_distance_table[VECTOR_DISTANCE_DOT][VECTOR_TYPE_F32] = float32_distance_dot_rvv;
186+
dispatch_distance_table[VECTOR_DISTANCE_DOT][VECTOR_TYPE_F16] = float16_distance_dot_rvv;
187+
dispatch_distance_table[VECTOR_DISTANCE_DOT][VECTOR_TYPE_BF16] = bfloat16_distance_dot_rvv;
188+
dispatch_distance_table[VECTOR_DISTANCE_DOT][VECTOR_TYPE_U8] = uint8_distance_dot_rvv;
189+
dispatch_distance_table[VECTOR_DISTANCE_DOT][VECTOR_TYPE_I8] = int8_distance_dot_rvv;
190+
191+
dispatch_distance_table[VECTOR_DISTANCE_L1][VECTOR_TYPE_F32] = float32_distance_l1_rvv;
192+
dispatch_distance_table[VECTOR_DISTANCE_L1][VECTOR_TYPE_F16] = float16_distance_l1_rvv;
193+
dispatch_distance_table[VECTOR_DISTANCE_L1][VECTOR_TYPE_BF16] = bfloat16_distance_l1_rvv;
194+
dispatch_distance_table[VECTOR_DISTANCE_L1][VECTOR_TYPE_U8] = uint8_distance_l1_rvv;
195+
dispatch_distance_table[VECTOR_DISTANCE_L1][VECTOR_TYPE_I8] = int8_distance_l1_rvv;
196+
197+
dispatch_distance_table[VECTOR_DISTANCE_HAMMING][VECTOR_TYPE_BIT] = bit1_distance_hamming_rvv;
198+
199+
distance_backend_name = "RVV";
200+
#endif
201+
}

‎src/distance-rvv.h‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
//
2+
// distance-rvv.h
3+
// sqlitevector
4+
//
5+
// Created by Afonso Bordado on 2026/02/19.
6+
//
7+
8+
#ifndef __VECTOR_DISTANCE_RVV__
9+
#define __VECTOR_DISTANCE_RVV__
10+
11+
#include <stdio.h>
12+
13+
void init_distance_functions_rvv (void);
14+
15+
#endif

0 commit comments

Comments
 (0)