Add simd support detection logic

Author: SongChujun

core/trino-main/pom.xml

@@ -556,4 +556,29 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <configuration>
+                        <!-- Ensure incubator Vector API is on the module path for javac -->
+                        <compilerArgs combine.self="merge">
+                            <arg>${extraJavaVectorArgs}</arg>
+                        </compilerArgs>
+                    </configuration>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-javadoc-plugin</artifactId>
+                    <configuration>
+                        <!-- Ensure javadoc resolves incubator Vector API -->
+                        <additionalOptions combine.self="merge">${extraJavaVectorArgs}</additionalOptions>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
 </project>

core/trino-main/src/main/java/io/trino/FeaturesConfig.java

@@ -94,6 +94,7 @@ public class FeaturesConfig
      * default value is overwritten for fault tolerant execution in {@link #applyFaultTolerantExecutionDefaults()}}
      */
     private CompressionCodec exchangeCompressionCodec = NONE;
+    private BlockSerdeVectorizedNullSuppressionStrategy blockSerdeVectorizedNullSuppressionStrategy = BlockSerdeVectorizedNullSuppressionStrategy.AUTO;
     private boolean pagesIndexEagerCompactionEnabled;
     private boolean omitDateTimeTypePrecision;
     private int maxRecursionDepth = 10;
@@ -133,6 +134,12 @@ public enum DataIntegrityVerification
         /**/;
     }
 
+    public enum BlockSerdeVectorizedNullSuppressionStrategy
+    {
+        AUTO,
+        NONE,
+    }
+
     public boolean isOmitDateTimeTypePrecision()
     {
         return omitDateTimeTypePrecision;
@@ -366,6 +373,19 @@ public FeaturesConfig setExchangeCompressionCodec(CompressionCodec exchangeCompr
         return this;
     }
 
+    @Config("experimental.blockserde-vectorized-null-suppression-strategy")
+    @ConfigDescription("Strategy used for vectorized null suppression in block serde")
+    public FeaturesConfig setBlockSerdeVectorizedNullSuppressionStrategy(BlockSerdeVectorizedNullSuppressionStrategy blockSerdeVectorizedNullSuppressionStrategy)
+    {
+        this.blockSerdeVectorizedNullSuppressionStrategy = blockSerdeVectorizedNullSuppressionStrategy;
+        return this;
+    }
+
+    public BlockSerdeVectorizedNullSuppressionStrategy getBlockSerdeVectorizedNullSuppressionStrategy()
+    {
+        return blockSerdeVectorizedNullSuppressionStrategy;
+    }
+
     public DataIntegrityVerification getExchangeDataIntegrityVerification()
     {
         return exchangeDataIntegrityVerification;

core/trino-main/src/main/java/io/trino/server/ServerMainModule.java

@@ -100,6 +100,7 @@
 import io.trino.server.protocol.PreparedStatementEncoder;
 import io.trino.server.protocol.spooling.SpoolingServerModule;
 import io.trino.server.remotetask.HttpLocationFactory;
+import io.trino.simd.BlockEncodingSimdSupport;
 import io.trino.spi.PageIndexerFactory;
 import io.trino.spi.PageSorter;
 import io.trino.spi.VersionEmbedder;
@@ -427,6 +428,9 @@ protected void setup(Binder binder)
                 .to(ServerPluginsProvider.class).in(Scopes.SINGLETON);
         configBinder(binder).bindConfig(ServerPluginsProviderConfig.class);
 
+        // SIMD support
+        binder.bind(BlockEncodingSimdSupport.class).in(Scopes.SINGLETON);
+
         // block encodings
         binder.bind(BlockEncodingManager.class).in(Scopes.SINGLETON);
         jsonBinder(binder).addSerializerBinding(Block.class).to(BlockJsonSerde.Serializer.class);

core/trino-main/src/main/java/io/trino/simd/BlockEncodingSimdSupport.java

@@ -0,0 +1,96 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.simd;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import io.trino.FeaturesConfig;
+import io.trino.spi.SimdSupport;
+import io.trino.util.MachineInfo;
+import jdk.incubator.vector.ByteVector;
+import jdk.incubator.vector.IntVector;
+import jdk.incubator.vector.LongVector;
+import jdk.incubator.vector.ShortVector;
+import oshi.hardware.CentralProcessor.ProcessorIdentifier;
+
+import java.util.EnumSet;
+import java.util.Set;
+
+import static io.trino.FeaturesConfig.BlockSerdeVectorizedNullSuppressionStrategy.AUTO;
+import static io.trino.util.MachineInfo.readCpuFlags;
+import static java.util.Locale.ENGLISH;
+
+@Singleton
+public final class BlockEncodingSimdSupport
+{
+    public static final int MINIMUM_SIMD_LENGTH = 512;
+    private final SimdSupport simdSupport;
+    private static final SimdSupport AUTO_DETECTED_SUPPORT = detectSimd();
+
+    @Inject
+    public BlockEncodingSimdSupport(
+            FeaturesConfig featuresConfig)
+    {
+        this(featuresConfig.getBlockSerdeVectorizedNullSuppressionStrategy().equals(AUTO));
+    }
+
+    public BlockEncodingSimdSupport(
+            boolean enableAutoDetectedSimdSupport)
+    {
+        if (enableAutoDetectedSimdSupport) {
+            simdSupport = AUTO_DETECTED_SUPPORT;
+        }
+        else {
+            simdSupport = SimdSupport.NONE;
+        }
+    }
+
+    private static SimdSupport detectSimd()
+    {
+        ProcessorIdentifier id = MachineInfo.getProcessorInfo();
+
+        String vendor = id.getVendor().toLowerCase(ENGLISH);
+
+        if (vendor.contains("intel") || vendor.contains("amd")) {
+            return detectX86SimdSupport();
+        }
+
+        return SimdSupport.NONE;
+    }
+
+    private static SimdSupport detectX86SimdSupport()
+    {
+        enum X86SimdInstructionSet {
+            avx512f,
+            avx512vbmi2
+        }
+
+        Set<String> flags = readCpuFlags();
+        EnumSet<X86SimdInstructionSet> x86Flags = EnumSet.noneOf(X86SimdInstructionSet.class);
+
+        if (!flags.isEmpty()) {
+            for (X86SimdInstructionSet instructionSet : X86SimdInstructionSet.values()) {
+                if (flags.contains(instructionSet.name())) {
+                    x86Flags.add(instructionSet);
+                }
+            }
+        }
+
+        return new SimdSupport(
+                (ByteVector.SPECIES_PREFERRED.vectorBitSize() >= MINIMUM_SIMD_LENGTH) && (x86Flags.contains(X86SimdInstructionSet.avx512vbmi2)),
+                (ShortVector.SPECIES_PREFERRED.vectorBitSize() >= MINIMUM_SIMD_LENGTH) && (x86Flags.contains(X86SimdInstructionSet.avx512vbmi2)),
+                (IntVector.SPECIES_PREFERRED.vectorBitSize() >= MINIMUM_SIMD_LENGTH) && (x86Flags.contains(X86SimdInstructionSet.avx512f)),
+                (LongVector.SPECIES_PREFERRED.vectorBitSize() >= MINIMUM_SIMD_LENGTH) && (x86Flags.contains(X86SimdInstructionSet.avx512f)));
+    }
+}

core/trino-main/src/main/java/io/trino/util/MachineInfo.java

@@ -14,14 +14,25 @@
 package io.trino.util;
 
 import com.google.common.base.StandardSystemProperty;
+import com.google.common.collect.ImmutableSet;
 import oshi.SystemInfo;
+import oshi.hardware.CentralProcessor;
+import oshi.hardware.CentralProcessor.ProcessorIdentifier;
 
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static java.lang.Math.min;
+import static java.util.Locale.ENGLISH;
 
 public final class MachineInfo
 {
     // cache physical processor count, so that it's not queried multiple times during tests
     private static volatile int physicalProcessorCount = -1;
+    private static final SystemInfo SYSTEM_INFO = new SystemInfo();
 
     private MachineInfo() {}
 
@@ -38,7 +49,7 @@ public static int getAvailablePhysicalProcessorCount()
         if ("amd64".equals(osArch) || "x86_64".equals(osArch)) {
             // Oshi can recognize physical processor count (without hyper threading) for x86 platforms.
             // However, it doesn't correctly recognize physical processor count for ARM platforms.
-            totalPhysicalProcessorCount = new SystemInfo()
+            totalPhysicalProcessorCount = SYSTEM_INFO
                     .getHardware()
                     .getProcessor()
                     .getPhysicalProcessorCount();
@@ -52,4 +63,68 @@ public static int getAvailablePhysicalProcessorCount()
         physicalProcessorCount = min(totalPhysicalProcessorCount, availableProcessorCount);
         return physicalProcessorCount;
     }
+
+    public static ProcessorIdentifier getProcessorInfo()
+    {
+        return SYSTEM_INFO.getHardware().getProcessor().getProcessorIdentifier();
+    }
+
+    public static Set<String> readCpuFlags()
+    {
+        CentralProcessor cpu = SYSTEM_INFO.getHardware().getProcessor();
+        List<String> flags = cpu.getFeatureFlags();
+        if (flags == null || flags.isEmpty()) {
+            return ImmutableSet.of();
+        }
+        // Each element of flags represents the hardware support for an individual core, so we're want to calculate flags
+        // advertised by all cores
+        Set<String> intersection = null;
+
+        for (String line : flags) {
+            if (line == null || line.isBlank()) {
+                continue;
+            }
+
+            // Strip the "flags:" / "Features:" prefix if present.
+            String body = line;
+            int colon = line.indexOf(':');
+            if (colon >= 0) {
+                body = line.substring(colon + 1);
+            }
+
+            // Tokenize + normalize.
+            Set<String> tokens = Arrays.stream(body.trim().split("\\s+"))
+                    .map(token -> normalizeFlag(token))
+                    .filter(token -> !token.isEmpty())
+                    .collect(toImmutableSet());
+
+            if (tokens.isEmpty()) {
+                continue;
+            }
+
+            if (intersection == null) {
+                intersection = new HashSet<>(tokens);
+            }
+            else {
+                intersection.retainAll(tokens);
+                if (intersection.isEmpty()) {
+                    break; // nothing in common
+                }
+            }
+        }
+
+        return intersection == null ? ImmutableSet.of() : intersection;
+    }
+
+    public static String normalizeFlag(String flag)
+    {
+        flag = flag.toLowerCase(ENGLISH).replace("_", "").trim();
+
+        // Skip stray keys that may sneak in if the colon wasn’t found.
+        if (flag.equals("flags") || flag.equals("features")) {
+            return "";
+        }
+
+        return flag;
+    }
 }

core/trino-main/src/test/java/io/trino/sql/analyzer/TestFeaturesConfig.java

@@ -17,6 +17,7 @@
 import com.google.common.collect.ImmutableMap;
 import io.airlift.units.DataSize;
 import io.trino.FeaturesConfig;
+import io.trino.FeaturesConfig.BlockSerdeVectorizedNullSuppressionStrategy;
 import io.trino.FeaturesConfig.DataIntegrityVerification;
 import org.junit.jupiter.api.Test;
 
@@ -54,6 +55,7 @@ public void testDefaults()
                 .setMemoryRevokingThreshold(0.9)
                 .setMemoryRevokingTarget(0.5)
                 .setExchangeCompressionCodec(NONE)
+                .setBlockSerdeVectorizedNullSuppressionStrategy(BlockSerdeVectorizedNullSuppressionStrategy.AUTO)
                 .setExchangeDataIntegrityVerification(DataIntegrityVerification.ABORT)
                 .setPagesIndexEagerCompactionEnabled(false)
                 .setFilterAndProjectMinOutputPageSize(DataSize.of(500, KILOBYTE))
@@ -89,6 +91,7 @@ public void testExplicitPropertyMappings()
                 .put("memory-revoking-threshold", "0.2")
                 .put("memory-revoking-target", "0.8")
                 .put("exchange.compression-codec", "ZSTD")
+                .put("experimental.blockserde-vectorized-null-suppression-strategy", "NONE")
                 .put("exchange.data-integrity-verification", "RETRY")
                 .put("pages-index.eager-compaction-enabled", "true")
                 .put("filter-and-project-min-output-page-size", "1MB")
@@ -121,6 +124,7 @@ public void testExplicitPropertyMappings()
                 .setMemoryRevokingThreshold(0.2)
                 .setMemoryRevokingTarget(0.8)
                 .setExchangeCompressionCodec(ZSTD)
+                .setBlockSerdeVectorizedNullSuppressionStrategy(BlockSerdeVectorizedNullSuppressionStrategy.NONE)
                 .setExchangeDataIntegrityVerification(DataIntegrityVerification.RETRY)
                 .setPagesIndexEagerCompactionEnabled(true)
                 .setFilterAndProjectMinOutputPageSize(DataSize.of(1, MEGABYTE))

core/trino-spi/src/main/java/io/trino/spi/SimdSupport.java

@@ -0,0 +1,24 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.spi;
+
+public record SimdSupport(
+        boolean expandAndCompressByte,
+        boolean expandAndCompressShort,
+        boolean expandAndCompressInt,
+        boolean expandAndCompressLong)
+{
+    public static final SimdSupport NONE = new SimdSupport(false, false, false, false);
+    public static final SimdSupport ALL = new SimdSupport(true, true, true, true);
+}