move FP32 logic to the request level

mgravell · mgravell · commit 16a866f63137 · 2026-05-07T16:18:26.000+01:00
diff --git a/src/StackExchange.Redis/VectorSetAddMessage.cs b/src/StackExchange.Redis/VectorSetAddMessage.cs
@@ -12,13 +12,14 @@ internal abstract class VectorSetAddMessage(
     VectorSetQuantization quantization,
     int? buildExplorationFactor,
     int? maxConnections,
-    bool useCheckAndSet) : Message(db, flags, RedisCommand.VADD)
+    bool useCheckAndSet,
+    bool useFp32) : Message(db, flags, RedisCommand.VADD)
 {
-    public override int ArgCount => GetArgCount(UseFp32);
+    public override int ArgCount => GetArgCount();
 
-    private int GetArgCount(bool packed)
+    private int GetArgCount()
     {
-        var count = 2 + GetElementArgCount(packed); // key, element and either "FP32 {vector}" or VALUES {num}"
+        var count = 2 + GetElementArgCount(); // key, element and either "FP32 {vector}" or VALUES {num}"
         if (reducedDimensions.HasValue) count += 2; // [REDUCE {dim}]
 
         if (useCheckAndSet) count++; // [CAS]
@@ -35,45 +36,34 @@ private int GetArgCount(bool packed)
         return count;
     }
 
-    public abstract int GetElementArgCount(bool packed);
+    public abstract int GetElementArgCount();
     public abstract int GetAttributeArgCount();
 
     public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy)
         => serverSelectionStrategy.HashSlot(key);
 
-    private static readonly bool CanUseFp32 = BitConverter.IsLittleEndian && CheckFp32();
+    internal static readonly bool CanUseFp32 = BitConverter.IsLittleEndian && CheckFp32();
+    internal bool UseFp32 { get; } = useFp32 & CanUseFp32; // evaluated during .ctor
 
     private static bool CheckFp32() // check endianness with a known value
     {
         // ReSharper disable once CompareOfFloatsByEqualityOperator - expect exact
         return MemoryMarshal.Cast<byte, float>("\0\0(B"u8)[0] == 42;
     }
 
-#if DEBUG
-    private static int _fp32Disabled;
-    internal static bool UseFp32 => CanUseFp32 & Volatile.Read(ref _fp32Disabled) == 0;
-    internal static void SuppressFp32() => Interlocked.Increment(ref _fp32Disabled);
-    internal static void RestoreFp32() => Interlocked.Decrement(ref _fp32Disabled);
-#else
-    internal static bool UseFp32 => CanUseFp32;
-    internal static void SuppressFp32() { }
-    internal static void RestoreFp32() { }
-#endif
-
-    protected abstract void WriteElement(bool packed, PhysicalConnection physical);
+    protected abstract void WriteElement(PhysicalConnection physical);
 
     protected override void WriteImpl(PhysicalConnection physical)
     {
-        bool packed = UseFp32; // snapshot to avoid race in debug scenarios
-        physical.WriteHeader(Command, GetArgCount(packed));
+        physical.WriteHeader(Command, GetArgCount());
         physical.Write(key);
         if (reducedDimensions.HasValue)
         {
             physical.WriteBulkString("REDUCE"u8);
             physical.WriteBulkString(reducedDimensions.GetValueOrDefault());
         }
 
-        WriteElement(packed, physical);
+        WriteElement(physical);
         if (useCheckAndSet) physical.WriteBulkString("CAS"u8);
 
         switch (quantization)
@@ -118,27 +108,29 @@ internal sealed class VectorSetAddMemberMessage(
         bool useCheckAndSet,
         RedisValue element,
         ReadOnlyMemory<float> values,
-        string? attributesJson) : VectorSetAddMessage(
+        string? attributesJson,
+        bool useFp32) : VectorSetAddMessage(
         db,
         flags,
         key,
         reducedDimensions,
         quantization,
         buildExplorationFactor,
         maxConnections,
-        useCheckAndSet)
+        useCheckAndSet,
+        useFp32)
     {
         private readonly string? _attributesJson = string.IsNullOrWhiteSpace(attributesJson) ? null : attributesJson;
-        public override int GetElementArgCount(bool packed)
+        public override int GetElementArgCount()
             => 2 // "FP32 {vector}" or "VALUES {num}"
-               + (packed ? 0 : values.Length); // {vector...}"
+               + (UseFp32 ? 0 : values.Length); // {vector...}"
 
         public override int GetAttributeArgCount()
             => _attributesJson is null ? 0 : 2; // [SETATTR {attributes}]
 
-        protected override void WriteElement(bool packed, PhysicalConnection physical)
+        protected override void WriteElement(PhysicalConnection physical)
         {
-            if (packed)
+            if (UseFp32)
             {
                 physical.WriteBulkString("FP32"u8);
                 physical.WriteBulkString(MemoryMarshal.AsBytes(values.Span));
diff --git a/src/StackExchange.Redis/VectorSetAddRequest.cs b/src/StackExchange.Redis/VectorSetAddRequest.cs
@@ -38,6 +38,8 @@ public static VectorSetAddRequest Member(
     /// </summary>
     public int? ReducedDimensions { get; set; }
 
+    internal bool UseFp32 { get; set; } = true; // for testing
+
     /// <summary>
     /// Quantization type - Int8 (Q8), None (NOQUANT), or Binary (BIN). Default: Int8.
     /// </summary>
@@ -74,6 +76,7 @@ internal override VectorSetAddMessage ToMessage(RedisKey key, int db, CommandFla
                 UseCheckAndSet,
                 element,
                 values,
-                attributesJson);
+                attributesJson,
+                UseFp32);
     }
 }
diff --git a/src/StackExchange.Redis/VectorSetSimilaritySearchMessage.cs b/src/StackExchange.Redis/VectorSetSimilaritySearchMessage.cs
@@ -11,7 +11,8 @@ internal abstract class VectorSetSimilaritySearchMessage(
     double epsilon,
     int searchExplorationFactor,
     string? filterExpression,
-    int maxFilteringEffort) : Message(db, flags, RedisCommand.VSIM)
+    int maxFilteringEffort,
+    bool useFp32) : Message(db, flags, RedisCommand.VSIM)
 {
     // For "FP32" and "VALUES" scenarios; in the future we might want other vector sizes / encodings - for
     // example, there could be some "FP16" or "FP8" transport that requires a ROM-short or ROM-sbyte from
@@ -27,15 +28,16 @@ internal sealed class VectorSetSimilaritySearchBySingleVectorMessage(
         double epsilon,
         int searchExplorationFactor,
         string? filterExpression,
-        int maxFilteringEffort) : VectorSetSimilaritySearchMessage(db, flags, vsimFlags, key, count, epsilon,
-        searchExplorationFactor, filterExpression, maxFilteringEffort)
+        int maxFilteringEffort,
+        bool useFp32) : VectorSetSimilaritySearchMessage(db, flags, vsimFlags, key, count, epsilon,
+        searchExplorationFactor, filterExpression, maxFilteringEffort, useFp32)
     {
-        internal override int GetSearchTargetArgCount(bool packed) =>
-            packed ? 2 : 2 + vector.Length; // FP32 {vector} or VALUES {num} {vector}
+        internal override int GetSearchTargetArgCount() =>
+            UseFp32 ? 2 : (2 + vector.Length); // FP32 {vector} or VALUES {num} {vector}
 
-        internal override void WriteSearchTarget(bool packed, PhysicalConnection physical)
+        internal override void WriteSearchTarget(PhysicalConnection physical)
         {
-            if (packed)
+            if (UseFp32)
             {
                 physical.WriteBulkString("FP32"u8);
                 physical.WriteBulkString(System.Runtime.InteropServices.MemoryMarshal.AsBytes(vector.Span));
@@ -63,20 +65,21 @@ internal sealed class VectorSetSimilaritySearchByMemberMessage(
         double epsilon,
         int searchExplorationFactor,
         string? filterExpression,
-        int maxFilteringEffort) : VectorSetSimilaritySearchMessage(db, flags, vsimFlags, key, count, epsilon,
-        searchExplorationFactor, filterExpression, maxFilteringEffort)
+        int maxFilteringEffort,
+        bool useFp32) : VectorSetSimilaritySearchMessage(db, flags, vsimFlags, key, count, epsilon,
+        searchExplorationFactor, filterExpression, maxFilteringEffort, useFp32)
     {
-        internal override int GetSearchTargetArgCount(bool packed) => 2; // ELE {member}
+        internal override int GetSearchTargetArgCount() => 2; // ELE {member}
 
-        internal override void WriteSearchTarget(bool packed, PhysicalConnection physical)
+        internal override void WriteSearchTarget(PhysicalConnection physical)
         {
             physical.WriteBulkString("ELE"u8);
             physical.WriteBulkString(member);
         }
     }
 
-    internal abstract int GetSearchTargetArgCount(bool packed);
-    internal abstract void WriteSearchTarget(bool packed, PhysicalConnection physical);
+    internal abstract int GetSearchTargetArgCount();
+    internal abstract void WriteSearchTarget(PhysicalConnection physical);
 
     public ResultProcessor<Lease<VectorSetSimilaritySearchResult>?> GetResultProcessor() =>
         VectorSetSimilaritySearchProcessor.Instance;
@@ -177,11 +180,11 @@ internal enum VsimFlags
 
     private bool HasFlag(VsimFlags flag) => (vsimFlags & flag) != 0;
 
-    public override int ArgCount => GetArgCount(VectorSetAddMessage.UseFp32);
+    public override int ArgCount => GetArgCount();
 
-    private int GetArgCount(bool packed)
+    private int GetArgCount()
     {
-        int argCount = 1 + GetSearchTargetArgCount(packed); // {key} and whatever we need for the vector/element portion
+        int argCount = 1 + GetSearchTargetArgCount(); // {key} and whatever we need for the vector/element portion
         if (HasFlag(VsimFlags.WithScores)) argCount++; // [WITHSCORES]
         if (HasFlag(VsimFlags.WithAttributes)) argCount++; // [WITHATTRIBS]
         if (HasFlag(VsimFlags.Count)) argCount += 2; // [COUNT {count}]
@@ -194,17 +197,18 @@ private int GetArgCount(bool packed)
         return argCount;
     }
 
+    internal bool UseFp32 { get; } = useFp32 & VectorSetAddMessage.CanUseFp32; // evaluated during .ctor
+
     protected override void WriteImpl(PhysicalConnection physical)
     {
         // snapshot to avoid race in debug scenarios
-        bool packed = VectorSetAddMessage.UseFp32;
-        physical.WriteHeader(Command, GetArgCount(packed));
+        physical.WriteHeader(Command, GetArgCount());
 
         // Write key
         physical.Write(key);
 
         // Write search target: either "ELE {member}" or vector data
-        WriteSearchTarget(packed, physical);
+        WriteSearchTarget(physical);
 
         if (HasFlag(VsimFlags.WithScores))
         {
diff --git a/src/StackExchange.Redis/VectorSetSimilaritySearchRequest.cs b/src/StackExchange.Redis/VectorSetSimilaritySearchRequest.cs
@@ -26,7 +26,8 @@ internal override VectorSetSimilaritySearchMessage ToMessage(RedisKey key, int d
                 _epsilon,
                 _searchExplorationFactor,
                 _filterExpression,
-                _maxFilteringEffort);
+                _maxFilteringEffort,
+                UseFp32);
     }
 
     private sealed class VectorSetSimilarityVectorSingleSearchRequest(ReadOnlyMemory<float> vector)
@@ -43,9 +44,12 @@ internal override VectorSetSimilaritySearchMessage ToMessage(RedisKey key, int d
                 _epsilon,
                 _searchExplorationFactor,
                 _filterExpression,
-                _maxFilteringEffort);
+                _maxFilteringEffort,
+                UseFp32);
     }
 
+    internal bool UseFp32 { get; set; } = true; // for testing
+
     // snapshot the values; I don't trust people not to mutate the object behind my back
     internal abstract VectorSetSimilaritySearchMessage ToMessage(RedisKey key, int db, CommandFlags flags);
 
diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixedVectorSetTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixedVectorSetTests.cs
@@ -22,17 +22,11 @@ public void VectorSetAdd_Fp32()
         {
             if (BitConverter.IsLittleEndian)
             {
-                Assert.True(VectorSetAddMessage.UseFp32);
-#if DEBUG // can be suppressed
-                VectorSetAddMessage.SuppressFp32();
-                Assert.False(VectorSetAddMessage.UseFp32);
-                VectorSetAddMessage.RestoreFp32();
-                Assert.True(VectorSetAddMessage.UseFp32);
-#endif
+                Assert.True(VectorSetAddMessage.CanUseFp32);
             }
             else
             {
-                Assert.False(VectorSetAddMessage.UseFp32);
+                Assert.False(VectorSetAddMessage.CanUseFp32);
             }
         }
 
diff --git a/tests/StackExchange.Redis.Tests/VectorSetIntegrationTests.cs b/tests/StackExchange.Redis.Tests/VectorSetIntegrationTests.cs
diff --git a/tests/StackExchange.Redis.Tests/VectorSetUnitTests.cs b/tests/StackExchange.Redis.Tests/VectorSetUnitTests.cs

Original file line number	Diff line number	Diff line change
`@@ -22,17 +22,11 @@ public void VectorSetAdd_Fp32()`
`22`	`22`	`{`
`23`	`23`	`if (BitConverter.IsLittleEndian)`
`24`	`24`	`{`
`25`		`- Assert.True(VectorSetAddMessage.UseFp32);`
`26`		`-#if DEBUG // can be suppressed`
`27`		`- VectorSetAddMessage.SuppressFp32();`
`28`		`- Assert.False(VectorSetAddMessage.UseFp32);`
`29`		`- VectorSetAddMessage.RestoreFp32();`
`30`		`- Assert.True(VectorSetAddMessage.UseFp32);`
`31`		`-#endif`
	`25`	`+ Assert.True(VectorSetAddMessage.CanUseFp32);`
`32`	`26`	`}`
`33`	`27`	`else`
`34`	`28`	`{`
`35`		`- Assert.False(VectorSetAddMessage.UseFp32);`
	`29`	`+ Assert.False(VectorSetAddMessage.CanUseFp32);`
`36`	`30`	`}`
`37`	`31`	`}`
`38`	`32`