Introduce an index level setting: index.vectors.indexing.use_gpu

index.vectors.indexing.use_gpu has 3 options:
- auto (null) default: use gpu indexing when available
- false: don't use gpu indexing
- true: use gpu indexing and if not available, throw an error

Author: mayya-sharipova

server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java

@@ -246,6 +246,7 @@ public final class IndexScopedSettings extends AbstractScopedSettings {
         if (SYNTHETIC_VECTORS) {
             settings.add(IndexSettings.INDEX_MAPPING_SOURCE_SYNTHETIC_VECTORS_SETTING);
         }
+        settings.add(IndexSettings.VECTORS_INDEXING_USE_GPU_SETTING);
         BUILT_IN_INDEX_SETTINGS = Collections.unmodifiableSet(settings);
     };
 

server/src/main/java/org/elasticsearch/index/IndexSettings.java

@@ -65,6 +65,7 @@
  * be called for each settings update.
  */
 public final class IndexSettings {
+
     public static final Setting<List<String>> DEFAULT_FIELD_SETTING = Setting.stringListSetting(
         "index.query.default_field",
         Collections.singletonList("*"),
@@ -856,6 +857,32 @@ private static String getIgnoreAboveDefaultValue(final Settings settings) {
         Property.Final
     );
 
+    /**
+     * An enum for the tri-state value of the `index.vectors.indexing.use_gpu` setting.
+     */
+    public enum GpuMode {
+        TRUE,
+        FALSE,
+        AUTO
+    }
+
+    /**
+     * Setting to control whether to use GPU for vectors indexing.
+     * Currently only applicable for index_options.type: hnsw.
+     *
+     * If unset or "auto", an automatic decision is made based on the presence of GPU, necessary libraries, vectors' count and dims.
+     * If set to <code>true</code>, GPU must be used for vectors indexing, and if GPU or necessary libraries are not available,
+     * an exception will be thrown.
+     * If set to <code>false</code>, GPU will not be used for vectors indexing.
+     */
+    public static final Setting<GpuMode> VECTORS_INDEXING_USE_GPU_SETTING = Setting.enumSetting(
+        GpuMode.class,
+        "index.vectors.indexing.use_gpu",
+        GpuMode.AUTO,
+        Property.IndexScope,
+        Property.Dynamic
+    );
+
     private final Index index;
     private final IndexVersion version;
     private final Logger logger;
@@ -954,6 +981,8 @@ private void setRetentionLeaseMillis(final TimeValue retentionLease) {
      */
     private volatile int maxSlicesPerScroll;
 
+    private volatile GpuMode useGpuForVectorsIndexing;
+
     /**
      * The maximum length of regex string allowed in a regexp query.
      */
@@ -1129,6 +1158,7 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
             && scopedSettings.get(RECOVERY_USE_SYNTHETIC_SOURCE_SETTING);
         useDocValuesSkipper = DOC_VALUES_SKIPPER && scopedSettings.get(USE_DOC_VALUES_SKIPPER);
         seqNoIndexOptions = scopedSettings.get(SEQ_NO_INDEX_OPTIONS_SETTING);
+        this.useGpuForVectorsIndexing = scopedSettings.get(VECTORS_INDEXING_USE_GPU_SETTING);
         if (recoverySourceSyntheticEnabled) {
             if (DiscoveryNode.isStateless(settings)) {
                 throw new IllegalArgumentException("synthetic recovery source is only allowed in stateful");
@@ -1151,6 +1181,8 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
             }
         }
 
+        scopedSettings.addSettingsUpdateConsumer(VECTORS_INDEXING_USE_GPU_SETTING, this::setUseGpuForVectorsIndexing);
+
         scopedSettings.addSettingsUpdateConsumer(
             MergePolicyConfig.INDEX_COMPOUND_FORMAT_SETTING,
             mergePolicyConfig::setCompoundFormatThreshold
@@ -1877,6 +1909,23 @@ private void setHnswEarlyTermination(boolean earlyTermination) {
         this.earlyTermination = earlyTermination;
     }
 
+    private void setUseGpuForVectorsIndexing(GpuMode useGpuForVectorsIndexing) {
+        this.useGpuForVectorsIndexing = useGpuForVectorsIndexing;
+    }
+
+    /**
+     * Whether to use GPU for vectors indexing.
+     * Currently only applicable for index_options.type: hnsw
+     *
+     * @return <code>GpuMode.TRUE</code> if GPU must be used for vectors indexing;
+     * <code>GpuMode.FALSE</code> if GPU will not be used, or
+     * <code>GpuMode.AUTO</code> if the setting is not set,
+     * meaning automatic decision is maded on the presence of GPU, libraries, vectors' count and dims.
+     */
+    public GpuMode useGpuForVectorsIndexing() {
+        return useGpuForVectorsIndexing;
+    }
+
     public SeqNoFieldMapper.SeqNoIndexOptions seqNoIndexOptions() {
         return seqNoIndexOptions;
     }

server/src/test/java/org/elasticsearch/index/IndexSettingsTests.java

@@ -921,4 +921,26 @@ public void testSame() {
         }
         assertTrue(IndexSettings.same(settings, differentOtherSettingBuilder.build()));
     }
+
+    public void testVectorsUseGpuSetting() {
+        IndexMetadata metadata = newIndexMeta(
+            "index",
+            Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, IndexVersion.current()).build()
+        );
+        IndexSettings settings = new IndexSettings(metadata, Settings.EMPTY);
+        assertEquals(IndexSettings.GpuMode.AUTO, settings.useGpuForVectorsIndexing());
+
+        settings.updateIndexMetadata(
+            newIndexMeta("index", Settings.builder().put(IndexSettings.VECTORS_INDEXING_USE_GPU_SETTING.getKey(), true).build())
+        );
+        assertEquals(IndexSettings.GpuMode.TRUE, settings.useGpuForVectorsIndexing());
+
+        settings.updateIndexMetadata(
+            newIndexMeta("index", Settings.builder().put(IndexSettings.VECTORS_INDEXING_USE_GPU_SETTING.getKey(), false).build())
+        );
+        assertEquals(IndexSettings.GpuMode.FALSE, settings.useGpuForVectorsIndexing());
+
+        settings.updateIndexMetadata(newIndexMeta("index", Settings.EMPTY));
+        assertEquals(IndexSettings.GpuMode.AUTO, settings.useGpuForVectorsIndexing());
+    }
 }

x-pack/plugin/gpu/src/main/java/org/elasticsearch/xpack/gpu/GPUPlugin.java

@@ -6,8 +6,10 @@
  */
 package org.elasticsearch.xpack.gpu;
 
+import com.nvidia.cuvs.CuVSResources;
+
 import org.elasticsearch.common.util.FeatureFlag;
-import org.elasticsearch.index.mapper.vectors.DenseVectorFieldMapper;
+import org.elasticsearch.index.IndexSettings;
 import org.elasticsearch.index.mapper.vectors.VectorsFormatProvider;
 import org.elasticsearch.plugins.MapperPlugin;
 import org.elasticsearch.plugins.Plugin;
@@ -19,15 +21,24 @@ public class GPUPlugin extends Plugin implements MapperPlugin {
 
     @Override
     public VectorsFormatProvider getVectorsFormatProvider() {
-        // TODO check indexSettings if it allows for GPU indexing
         return (indexSettings, indexOptions) -> {
-            if (GPU_FORMAT.isEnabled()
-                && GPUVectorsFormat.cuVSResourcesOrNull(false) != null
-                && indexOptions.getType() == DenseVectorFieldMapper.VectorIndexType.HNSW) {
-                return new GPUVectorsFormat();
-            } else {
-                return null;
+            if (GPU_FORMAT.isEnabled()) {
+                IndexSettings.GpuMode gpuMode = indexSettings.getValue(IndexSettings.VECTORS_INDEXING_USE_GPU_SETTING);
+                if (gpuMode == IndexSettings.GpuMode.TRUE) {
+                    CuVSResources resources = GPUVectorsFormat.cuVSResourcesOrNull(true);
+                    if (resources == null) {
+                        throw new IllegalArgumentException(
+                            "[index.vectors.indexing.use_gpu] was set to [true], but GPU resources are not accessible on the node."
+                        );
+                    } else {
+                        return new GPUVectorsFormat();
+                    }
+                }
+                if ((gpuMode == IndexSettings.GpuMode.AUTO) && GPUVectorsFormat.cuVSResourcesOrNull(false) != null) {
+                    return new GPUVectorsFormat();
+                }
             }
+            return null;
         };
     }
 }

x-pack/plugin/gpu/src/main/java/org/elasticsearch/xpack/gpu/codec/GPUVectorsFormat.java

@@ -56,7 +56,7 @@ public GPUVectorsFormat() {
     public KnnVectorsWriter fieldsWriter(SegmentWriteState state) throws IOException {
         CuVSResources cuVSResources = cuVSResourcesOrNull(true);
         if (cuVSResources == null) {
-            throw new IllegalArgumentException("GPU based vector search is not supported on this platform or java version");
+            throw new IllegalArgumentException("GPU based vector indexing is not supported on this platform or java version");
         }
         return new GPUToHNSWVectorsWriter(
             cuVSResources,
@@ -95,7 +95,7 @@ public static CuVSResources cuVSResourcesOrNull(boolean logError) {
                 } else {
                     msg = ": " + uoe.getMessage();
                 }
-                LOG.warn("GPU based vector search is not supported on this platform or java version; " + msg);
+                LOG.warn("GPU based vector indexing is not supported on this platform or java version; " + msg);
             }
         } catch (Throwable t) {
             if (logError) {