add implementation of float8 vector type (int8 quantization)

Author: sivukhin

libsql-sqlite3/Makefile.in

@@ -195,7 +195,7 @@ LIBOBJS0 = alter.lo analyze.lo attach.lo auth.lo \
          sqlite3session.lo select.lo sqlite3rbu.lo status.lo stmt.lo \
          table.lo threads.lo tokenize.lo treeview.lo trigger.lo \
          update.lo userauth.lo upsert.lo util.lo vacuum.lo \
-         vector.lo vectorfloat32.lo vectorfloat64.lo vectorfloat1bit.lo \
+         vector.lo vectorfloat32.lo vectorfloat64.lo vectorfloat1bit.lo vectorfloat8.lo \
          vectorIndex.lo vectordiskann.lo vectorvtab.lo \
          vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbemem.lo vdbesort.lo \
          vdbetrace.lo vdbevtab.lo \
@@ -306,6 +306,7 @@ SRC = \
   $(TOP)/src/vectorfloat1bit.c \
   $(TOP)/src/vectorfloat32.c \
   $(TOP)/src/vectorfloat64.c \
+  $(TOP)/src/vectorfloat8.c \
   $(TOP)/src/vectorIndexInt.h \
   $(TOP)/src/vectorIndex.c \
   $(TOP)/src/vectordiskann.c \
@@ -1148,6 +1149,9 @@ vectorfloat32.lo:	$(TOP)/src/vectorfloat32.c $(HDR)
 vectorfloat64.lo:	$(TOP)/src/vectorfloat64.c $(HDR)
 	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/vectorfloat64.c
 
+vectorfloat8.lo:	$(TOP)/src/vectorfloat8.c $(HDR)
+	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/vectorfloat8.c
+
 vectorIndex.lo:	$(TOP)/src/vectorIndex.c $(HDR)
 	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/vectorIndex.c
 

libsql-sqlite3/src/vector.c

@@ -43,6 +43,8 @@ size_t vectorDataSize(VectorType type, VectorDims dims){
       return dims * sizeof(double);
     case VECTOR_TYPE_FLOAT1BIT:
       return (dims + 7) / 8;
+    case VECTOR_TYPE_FLOAT8:
+      return ALIGN(dims, sizeof(float)) + sizeof(float) /* alpha */ + sizeof(float) /* shift */;
     default:
       assert(0);
   }
@@ -116,6 +118,8 @@ float vectorDistanceCos(const Vector *pVector1, const Vector *pVector2){
       return vectorF64DistanceCos(pVector1, pVector2);
     case VECTOR_TYPE_FLOAT1BIT:
       return vector1BitDistanceHamming(pVector1, pVector2);
+    case VECTOR_TYPE_FLOAT8:
+      return vectorF8DistanceCos(pVector1, pVector2);
     default:
       assert(0);
   }
@@ -253,7 +257,8 @@ static int vectorParseSqliteText(
 }
 
 static int vectorParseMeta(const unsigned char *pBlob, size_t nBlobSize, int *pType, int *pDims, size_t *pDataSize, char **pzErrMsg){
-  int nLeftoverBits;
+  int nTrailingBits;
+  int nTrailingBytes;
 
   if( nBlobSize % 2 == 0 ){
     *pType = VECTOR_TYPE_FLOAT32;
@@ -266,26 +271,34 @@ static int vectorParseMeta(const unsigned char *pBlob, size_t nBlobSize, int *pT
 
   if( *pType == VECTOR_TYPE_FLOAT32 ){
     if( nBlobSize % 4 != 0 ){
-      *pzErrMsg = sqlite3_mprintf("vector: f32 vector blob length must be divisible by 4 (excluding optional 'type'-byte): length=%d", nBlobSize);
+      *pzErrMsg = sqlite3_mprintf("vector: float32 vector blob length must be divisible by 4 (excluding optional 'type'-byte): length=%d", nBlobSize);
       return SQLITE_ERROR;
     }
     *pDims = nBlobSize / sizeof(float);
     *pDataSize = nBlobSize;
   }else if( *pType == VECTOR_TYPE_FLOAT64 ){
     if( nBlobSize % 8 != 0 ){
-      *pzErrMsg = sqlite3_mprintf("vector: f64 vector blob length must be divisible by 8 (excluding 'type'-byte): length=%d", nBlobSize);
+      *pzErrMsg = sqlite3_mprintf("vector: float64 vector blob length must be divisible by 8 (excluding 'type'-byte): length=%d", nBlobSize);
       return SQLITE_ERROR;
     }
     *pDims = nBlobSize / sizeof(double);
     *pDataSize = nBlobSize;
   }else if( *pType == VECTOR_TYPE_FLOAT1BIT ){
     if( nBlobSize == 0 || nBlobSize % 2 != 0 ){
-      *pzErrMsg = sqlite3_mprintf("vector: 1bit vector blob length must be divisible by 2 and not be empty (excluding 'type'-byte): length=%d", nBlobSize);
+      *pzErrMsg = sqlite3_mprintf("vector: float1bit vector blob length must be divisible by 2 and not be empty (excluding 'type'-byte): length=%d", nBlobSize);
       return SQLITE_ERROR;
     }
-    nLeftoverBits = pBlob[nBlobSize - 1];
-    *pDims = nBlobSize * 8 - nLeftoverBits;
+    nTrailingBits = pBlob[nBlobSize - 1];
+    *pDims = nBlobSize * 8 - nTrailingBits;
     *pDataSize = (*pDims + 7) / 8;
+  }else if( *pType == VECTOR_TYPE_FLOAT8 ){
+    if( nBlobSize < 2 || nBlobSize % 2 != 0 ){
+      *pzErrMsg = sqlite3_mprintf("vector: float8 vector blob length must be divisible by 2 and has at least 2 bytes (excluding 'type'-byte): length=%d", nBlobSize);
+      return SQLITE_ERROR;
+    }
+    nTrailingBytes = pBlob[nBlobSize - 1];
+    *pDims = (nBlobSize - 2) - sizeof(float) - sizeof(float) - nTrailingBytes;
+    *pDataSize = nBlobSize - 2;
   }else{
     *pzErrMsg = sqlite3_mprintf("vector: unexpected binary type: %d", *pType);
     return SQLITE_ERROR;
@@ -331,6 +344,9 @@ int vectorParseSqliteBlobWithType(
     case VECTOR_TYPE_FLOAT1BIT:
       vector1BitDeserializeFromBlob(pVector, pBlob, nDataSize);
       return 0;
+    case VECTOR_TYPE_FLOAT8:
+      vectorF8DeserializeFromBlob(pVector, pBlob, nDataSize);
+      return 0;
     default: 
       assert(0);
   }
@@ -429,6 +445,9 @@ void vectorDump(const Vector *pVector){
     case VECTOR_TYPE_FLOAT1BIT:
       vector1BitDump(pVector);
       break;
+    case VECTOR_TYPE_FLOAT8:
+      vectorF8Dump(pVector);
+      break;
     default:
       assert(0);
   }
@@ -451,20 +470,20 @@ void vectorMarshalToText(
 }
 
 static int vectorMetaSize(VectorType type, VectorDims dims){
-  int nMetaSize = 0;
   int nDataSize;
   if( type == VECTOR_TYPE_FLOAT32 ){
     return 0;
   }else if( type == VECTOR_TYPE_FLOAT64 ){
     return 1;
   }else if( type == VECTOR_TYPE_FLOAT1BIT ){
     nDataSize = vectorDataSize(type, dims);
-    nMetaSize++; // one byte which specify amount of leftover bits
-    if( nDataSize % 2 == 0 ){
-      nMetaSize++; // pad "leftover-bits" byte to the even length
-    }
-    nMetaSize++; // one byte for vector type
-    return nMetaSize;
+    // optional padding byte + "trailing-bits" byte + "vector-type" byte
+    return (nDataSize % 2 == 0 ? 1 : 0) + 1 + 1;
+  }else if( type == VECTOR_TYPE_FLOAT8 ){
+    nDataSize = vectorDataSize(type, dims);
+    assert( nDataSize % 2 == 0 );
+    /* padding byte + "trailing-bytes" byte + "vector-type" byte */
+    return 1 + 1 + 1;
   }else{
     assert( 0 );
   }
@@ -482,6 +501,15 @@ static void vectorSerializeMeta(const Vector *pVector, size_t nDataSize, unsigne
     assert( nBlobSize >= 3 );
     pBlob[nBlobSize - 1] = VECTOR_TYPE_FLOAT1BIT;
     pBlob[nBlobSize - 2] = 8 * (nBlobSize - 1) - pVector->dims;
+    if( vectorMetaSize(pVector->type, pVector->dims) == 3 ){
+      pBlob[nBlobSize - 3] = 0;
+    }
+  }else if( pVector->type == VECTOR_TYPE_FLOAT8 ){
+    assert( nBlobSize % 2 == 1 );
+    assert( nDataSize % 2 == 0 );
+    assert( nBlobSize == nDataSize + 3 );
+    pBlob[nBlobSize - 1] = VECTOR_TYPE_FLOAT8;
+    pBlob[nBlobSize - 2] = ALIGN(pVector->dims, sizeof(float)) - pVector->dims;
   }else{
     assert( 0 );
   }
@@ -520,25 +548,30 @@ void vectorSerializeWithMeta(
     case VECTOR_TYPE_FLOAT1BIT:
       vector1BitSerializeToBlob(pVector, pBlob, nDataSize);
       break;
+    case VECTOR_TYPE_FLOAT8:
+      vectorF8SerializeToBlob(pVector, pBlob, nDataSize);
+      break;
     default:
       assert(0);
   }
   vectorSerializeMeta(pVector, nDataSize, pBlob, nBlobSize);
   sqlite3_result_blob(context, (char*)pBlob, nBlobSize, sqlite3_free);
 }
 
-size_t vectorSerializeToBlob(const Vector *pVector, unsigned char *pBlob, size_t nBlobSize){
+void vectorSerializeToBlob(const Vector *pVector, unsigned char *pBlob, size_t nBlobSize){
   switch (pVector->type) {
     case VECTOR_TYPE_FLOAT32:
-      return vectorF32SerializeToBlob(pVector, pBlob, nBlobSize);
+      vectorF32SerializeToBlob(pVector, pBlob, nBlobSize);
+      break;
     case VECTOR_TYPE_FLOAT64:
-      return vectorF64SerializeToBlob(pVector, pBlob, nBlobSize);
+      vectorF64SerializeToBlob(pVector, pBlob, nBlobSize);
+      break;
     case VECTOR_TYPE_FLOAT1BIT:
-      return vector1BitSerializeToBlob(pVector, pBlob, nBlobSize);
+      vector1BitSerializeToBlob(pVector, pBlob, nBlobSize);
+      break;
     default:
       assert(0);
   }
-  return 0;
 }
 
 void vectorInitFromBlob(Vector *pVector, const unsigned char *pBlob, size_t nBlobSize){
@@ -644,6 +677,110 @@ static void vectorConvertFrom1Bit(const Vector *pFrom, Vector *pTo){
   }
 }
 
+static void vectorConvertFromF8(const Vector *pFrom, Vector *pTo){
+  int i;
+  u8 *src;
+  float alpha, shift;
+
+  float *dstF32;
+  double *dstF64;
+  u8 *dst1Bit;
+
+  assert( pFrom->dims == pTo->dims );
+  assert( pFrom->type != pTo->type );
+  assert( pFrom->type == VECTOR_TYPE_FLOAT8 );
+
+  vectorF8GetParameters(pFrom->data, pFrom->dims, &alpha, &shift);
+
+  src = pFrom->data;
+  if( pTo->type == VECTOR_TYPE_FLOAT32 ){
+    dstF32 = pTo->data;
+    for(i = 0; i < pFrom->dims; i++){
+      dstF32[i] = alpha * src[i] + shift;
+    }
+  }else if( pTo->type == VECTOR_TYPE_FLOAT64 ){
+    dstF64 = pTo->data;
+    for(i = 0; i < pFrom->dims; i++){
+      dstF64[i] = alpha * src[i] + shift;
+    }
+  }else if( pTo->type == VECTOR_TYPE_FLOAT1BIT ){
+    dst1Bit = pTo->data;
+    for(i = 0; i < pFrom->dims; i += 8){
+      dst1Bit[i / 8] = 0;
+    }
+    for(i = 0; i < pFrom->dims; i++){
+      if( (alpha * src[i] + shift) > 0 ){
+        dst1Bit[i / 8] |= (1 << (i & 7));
+      }
+    }
+  }else{
+    assert( 0 );
+  }
+}
+
+static inline int clip(float f, int minF, int maxF){
+  if( f < minF ){
+    return minF;
+  }else if( f > maxF ){
+    return maxF;
+  }
+  return (int)(f + 0.5);
+}
+
+#define MINMAX(i, value, minValue, maxValue) {if(i == 0){ minValue = (value); maxValue = (value);} else { minValue = MIN(minValue, (value)); maxValue = MAX(maxValue, (value)); }}
+
+static void vectorConvertToF8(const Vector *pFrom, Vector *pTo){
+  int i;
+  u8 *dst;
+  float alpha, shift;
+  float minF = 0, maxF = 0;
+
+  float *srcF32;
+  double *srcF64;
+  u8 *src1Bit;
+
+  assert( pFrom->dims == pTo->dims );
+  assert( pFrom->type != pTo->type );
+  assert( pTo->type == VECTOR_TYPE_FLOAT8 );
+
+  dst = pTo->data;
+  if( pFrom->type == VECTOR_TYPE_FLOAT32 ){
+    srcF32 = pFrom->data;
+    for(i = 0; i < pFrom->dims; i++){
+      MINMAX(i, srcF32[i], minF, maxF);
+    }
+    shift = minF;
+    alpha = (maxF - minF) / 255;
+    for(i = 0; i < pFrom->dims; i++){
+      dst[i] = clip((srcF32[i] - shift) / alpha, 0, 255);
+    }
+  }else if( pFrom->type == VECTOR_TYPE_FLOAT64 ){
+    srcF64 = pFrom->data;
+    for(i = 0; i < pFrom->dims; i++){
+      MINMAX(i, srcF64[i], minF, maxF);
+    }
+    shift = minF;
+    alpha = (maxF - minF) / 255;
+    for(i = 0; i < pFrom->dims; i++){
+      dst[i] = clip((srcF64[i] - shift) / alpha, 0, 255);
+    }
+  }else if( pFrom->type == VECTOR_TYPE_FLOAT1BIT ){
+    src1Bit = pFrom->data;
+    for(i = 0; i < pFrom->dims; i++){
+      MINMAX(i, ((src1Bit[i / 8] >> (i & 7)) & 1) ? +1 : -1, minF, maxF);
+    }
+    shift = minF;
+    alpha = (maxF - minF) / 255;
+    for(i = 0; i < pFrom->dims; i++){
+      dst[i] = clip(((((src1Bit[i / 8] >> (i & 7)) & 1) ? +1 : -1) - shift) / alpha, 0, 255);
+    }
+  }else{
+    assert( 0 );
+  }
+  vectorF8SetParameters(pTo->data, pTo->dims, alpha, shift);
+}
+
+
 void vectorConvert(const Vector *pFrom, Vector *pTo){
   assert( pFrom->dims == pTo->dims );
 
@@ -652,12 +789,16 @@ void vectorConvert(const Vector *pFrom, Vector *pTo){
     return;
   }
 
-  if( pFrom->type == VECTOR_TYPE_FLOAT32 ){
+  if( pTo->type == VECTOR_TYPE_FLOAT8 ){
+    vectorConvertToF8(pFrom, pTo);
+  }else if( pFrom->type == VECTOR_TYPE_FLOAT32 ){
     vectorConvertFromF32(pFrom, pTo);
   }else if( pFrom->type == VECTOR_TYPE_FLOAT64 ){
     vectorConvertFromF64(pFrom, pTo);
   }else if( pFrom->type == VECTOR_TYPE_FLOAT1BIT ){
     vectorConvertFrom1Bit(pFrom, pTo);
+  }else if( pFrom->type == VECTOR_TYPE_FLOAT8 ){
+    vectorConvertFromF8(pFrom, pTo);
   }else{
     assert( 0 );
   }
@@ -734,6 +875,14 @@ static void vector64Func(
   vectorFuncHintedType(context, argc, argv, VECTOR_TYPE_FLOAT64);
 }
 
+static void vector8Func(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  vectorFuncHintedType(context, argc, argv, VECTOR_TYPE_FLOAT8);
+}
+
 static void vector1BitFunc(
   sqlite3_context *context,
   int argc,
@@ -873,6 +1022,7 @@ void sqlite3RegisterVectorFunctions(void){
     FUNCTION(vector32,            1, 0, 0, vector32Func),
     FUNCTION(vector64,            1, 0, 0, vector64Func),
     FUNCTION(vector1bit,          1, 0, 0, vector1BitFunc),
+    FUNCTION(vector8,             1, 0, 0, vector8Func),
     FUNCTION(vector_extract,      1, 0, 0, vectorExtractFunc),
     FUNCTION(vector_distance_cos, 2, 0, 0, vectorDistanceCosFunc),
 

libsql-sqlite3/src/vectorIndex.c

@@ -383,6 +383,8 @@ static struct VectorColumnType VECTOR_COLUMN_TYPES[] = {
   { "F64_BLOB",   VECTOR_TYPE_FLOAT64 },
   { "FLOAT1BIT",  VECTOR_TYPE_FLOAT1BIT },
   { "F1BIT_BLOB", VECTOR_TYPE_FLOAT1BIT },
+  { "FLOAT8",     VECTOR_TYPE_FLOAT8 },
+  { "F8_BLOB",    VECTOR_TYPE_FLOAT8 },
 };
 
 /*