Merge pull request #35311 from vespa-engine/arnej/wip-simpler-annotations-7

Add SimpleIndexingAnnotations for memory reduction in indexing

Author: arnej27959

config-model-api/abi-spec.json

@@ -1333,6 +1333,7 @@
  "public double logserverNodeMemory()",
  "public double clusterControllerNodeMemory()",
  "public boolean useLegacyWandQueryParsing()",
+ "public boolean useSimpleAnnotations()",
  "public boolean sendProtobufQuerytree()",
  "public boolean forwardAllLogLevels()",
  "public long zookeeperPreAllocSize()",

config-model-api/src/main/java/com/yahoo/config/model/api/ModelContext.java

@@ -108,6 +108,7 @@ interface FeatureFlags {
  @ModelFeatureFlag(owners = {"arnej"}) default double logserverNodeMemory() { return 0.0; }
  @ModelFeatureFlag(owners = {"arnej"}) default double clusterControllerNodeMemory() { return 0.0; }
  @ModelFeatureFlag(owners = {"arnej"}) default boolean useLegacyWandQueryParsing() { return true; }
+ @ModelFeatureFlag(owners = {"arnej"}) default boolean useSimpleAnnotations() { return false; }
  @ModelFeatureFlag(owners = {"arnej"}) default boolean sendProtobufQuerytree() { return false; }
  @ModelFeatureFlag(owners = {"hmusum"}) default boolean forwardAllLogLevels() { return true; }
  @ModelFeatureFlag(owners = {"hmusum"}) default long zookeeperPreAllocSize() { return 65536L; }

config-model/src/main/java/com/yahoo/vespa/model/container/docproc/ContainerDocproc.java

@@ -29,13 +29,18 @@ public class ContainerDocproc extends ContainerSubsystem<DocprocChains> implemen
 
  public final Options options;
  private final Map<Pair<String, String>, String> fieldNameSchemaMap = new HashMap<>();
+ private final boolean useSimpleAnnotations;
 
  public ContainerDocproc(ContainerCluster<?> cluster, DocprocChains chains) {
- this(cluster, chains, Options.empty());
+ this(cluster, chains, Options.empty(), null);
  }
 
- private ContainerDocproc(ContainerCluster<?> cluster, DocprocChains chains, Options options) {
- this(cluster, chains, options, true);
+ public ContainerDocproc(ContainerCluster<?> cluster, DocprocChains chains, DeployState deployState) {
+ this(cluster, chains, Options.empty(), deployState, true);
+ }
+
+ private ContainerDocproc(ContainerCluster<?> cluster, DocprocChains chains, Options options, DeployState deployState) {
+ this(cluster, chains, options, deployState, true);
  }
 
  private void addSource(ContainerCluster<?> cluster, String name, SessionConfig.Type.Enum type) {
@@ -44,10 +49,11 @@ private void addSource(ContainerCluster<?> cluster, String name, SessionConfig.T
  cluster.addComponent(mbusClient);
  }
 
- public ContainerDocproc(ContainerCluster<?> cluster, DocprocChains chains, Options options, boolean addSourceClientProvider) {
+ public ContainerDocproc(ContainerCluster<?> cluster, DocprocChains chains, Options options, DeployState deployState, boolean addSourceClientProvider) {
  super(chains);
  assert (options != null) : "Null Options for " + this + " under cluster " + cluster.getName();
  this.options = options;
+ this.useSimpleAnnotations = deployState != null && deployState.featureFlags().useSimpleAnnotations();
 
  if (addSourceClientProvider) {
  addSource(cluster, "source", SessionConfig.Type.SOURCE);
@@ -80,6 +86,7 @@ public void getConfig(DocprocConfig.Builder builder) {
  if (getMaxQueueTimeMs() != null) {
  builder.maxqueuetimems(getMaxQueueTimeMs());
  }
+ builder.simpleAnnotations(useSimpleAnnotations);
  }
 
  @Override

config-model/src/main/java/com/yahoo/vespa/model/container/xml/ContainerModelBuilder.java

@@ -1360,7 +1360,7 @@ private ContainerDocproc buildDocproc(DeployState deployState, ApplicationContai
  DocprocChains chains = new DomDocprocChainsBuilder(docprocHandlerThreadpool).build(deployState, cluster, docprocElement);
 
  ContainerDocproc.Options docprocOptions = DocprocOptionsBuilder.build(docprocElement, deployState.getDeployLogger());
- return new ContainerDocproc(cluster, chains, docprocOptions, !standaloneBuilder);
+ return new ContainerDocproc(cluster, chains, docprocOptions, deployState, !standaloneBuilder);
  }
 
  private void addIncludes(Element parentElement) {

config-model/src/main/java/com/yahoo/vespa/model/content/Content.java

@@ -354,7 +354,7 @@ private void addDocproc(ContainerCluster<?> cluster, DeployState deployState) {
  if (cluster.getDocproc() == null) {
  DocprocChains chains = new DocprocChains(cluster, "docprocchains",
  new ContainerDocproc.Threadpool(deployState, null));
- ContainerDocproc containerDocproc = new ContainerDocproc(cluster, chains);
+ ContainerDocproc containerDocproc = new ContainerDocproc(cluster, chains, deployState);
  cluster.setDocproc(containerDocproc);
  }
  }

configserver/src/main/java/com/yahoo/vespa/config/server/deploy/ModelContextImpl.java

@@ -200,6 +200,7 @@ public static class FeatureFlags implements ModelContext.FeatureFlags {
  private final double logserverNodeMemory;
  private final double clusterControllerNodeMemory;
  private final boolean useLegacyWandQueryParsing;
+ private final boolean useSimpleAnnotations;
  private final boolean sendProtobufQuerytree;
  private final boolean forwardAllLogLevels;
  private final long zookeeperPreAllocSize;
@@ -247,6 +248,7 @@ public FeatureFlags(FlagSource source, ApplicationId appId, Version version) {
  this.logserverNodeMemory = PermanentFlags.LOGSERVER_NODE_MEMORY.bindTo(source).with(appId).with(version).value();
  this.clusterControllerNodeMemory = PermanentFlags.CLUSTER_CONTROLLER_NODE_MEMORY.bindTo(source).with(appId).with(version).value();
  this.useLegacyWandQueryParsing = Flags.USE_LEGACY_WAND_QUERY_PARSING.bindTo(source).with(appId).with(version).value();
+ this.useSimpleAnnotations = Flags.USE_SIMPLE_ANNOTATIONS.bindTo(source).with(appId).with(version).value();
  this.sendProtobufQuerytree = Flags.SEND_PROTOBUF_QUERYTREE.bindTo(source).with(appId).with(version).value();
  this.forwardAllLogLevels = PermanentFlags.FORWARD_ALL_LOG_LEVELS.bindTo(source).with(appId).with(version).value();
  this.zookeeperPreAllocSize = Flags.ZOOKEEPER_PRE_ALLOC_SIZE_KIB.bindTo(source).value();
@@ -295,6 +297,7 @@ public FeatureFlags(FlagSource source, ApplicationId appId, Version version) {
  @Override public double logserverNodeMemory() { return logserverNodeMemory; }
  @Override public double clusterControllerNodeMemory() { return clusterControllerNodeMemory; }
  @Override public boolean useLegacyWandQueryParsing() { return useLegacyWandQueryParsing; }
+ @Override public boolean useSimpleAnnotations() { return useSimpleAnnotations; }
  @Override public boolean sendProtobufQuerytree() { return sendProtobufQuerytree; }
  @Override public boolean forwardAllLogLevels() { return forwardAllLogLevels; }
  @Override public long zookeeperPreAllocSize() { return zookeeperPreAllocSize; }

docproc/src/main/java/com/yahoo/docproc/jdisc/DocumentProcessingHandler.java

@@ -109,6 +109,11 @@ public DocumentProcessingHandler(ComponentRegistry<DocumentProcessor> documentPr
  .setMetric(metric)
  .setContainerDocumentConfig(containerDocConfig),
  threadPool);
+
+ // Set simple annotations flag based on config
+ com.yahoo.document.annotation.internal.SimpleIndexingAnnotations.setEnabled(
+ docprocConfig.simpleAnnotations());
+
  docprocServiceRegistry.freeze();
  }
 

docproc/src/main/resources/configdefinitions/config.docproc.docproc.def

@@ -8,3 +8,7 @@ maxqueuetimems int default=-1
 # The number of threads in the DocprocHandler worker thread pool
 # numthreads no longer has an effect.
 numthreads int default=-1
+
+# Enable lightweight annotation representation for StringFieldValue.
+# When enabled, uses SimpleIndexingAnnotations (flat arrays) instead of full SpanTree objects.
+simpleAnnotations bool default=false

document/abi-spec.json

@@ -2173,8 +2173,12 @@
  "public java.util.Collection getSpanTrees()",
  "public final java.util.Map getSpanTreeMap()",
  "public com.yahoo.document.annotation.SpanTree getSpanTree(java.lang.String)",
+ "public boolean hasSpanTree(java.lang.String)",
  "public com.yahoo.document.annotation.SpanTree setSpanTree(com.yahoo.document.annotation.SpanTree)",
  "public com.yahoo.document.annotation.SpanTree removeSpanTree(java.lang.String)",
+ "public com.yahoo.document.annotation.internal.SimpleIndexingAnnotations createSimpleAnnotations()",
+ "public com.yahoo.document.annotation.internal.SimpleIndexingAnnotations getSimpleAnnotations()",
+ "public void setSimpleAnnotations(com.yahoo.document.annotation.internal.SimpleIndexingAnnotations)",
  "public java.lang.String getString()",
  "public java.lang.Object getWrappedValue()",
  "public void printXml(com.yahoo.document.serialization.XmlStream)",

document/src/main/java/com/yahoo/document/annotation/internal/SimpleIndexingAnnotations.java

@@ -0,0 +1,179 @@
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.document.annotation.internal;
+
+import com.yahoo.document.annotation.Annotation;
+import com.yahoo.document.annotation.AnnotationTypes;
+import com.yahoo.document.annotation.Span;
+import com.yahoo.document.annotation.SpanTree;
+import com.yahoo.document.annotation.SpanTrees;
+import com.yahoo.document.datatypes.StringFieldValue;
+
+import java.util.logging.Logger;
+
+/**
+ * Lightweight representation of TERM annotations for indexing.
+ * Uses flat arrays instead of object graphs.
+ * NOT part of public API - internal optimization for indexing performance.
+ *
+ * This class can only represent simple TERM annotations with:
+ * - Position (from, length)
+ * - Optional term override (when term differs from substring)
+ *
+ * @author havardpe
+ */
+public final class SimpleIndexingAnnotations {
+
+ private static final Logger log = Logger.getLogger(SimpleIndexingAnnotations.class.getName());
+
+ /**
+ * Global feature flag to enable/disable simple annotations representation.
+ * When enabled, uses SimpleIndexingAnnotations (flat arrays) instead of full SpanTree objects.
+ */
+ private static volatile boolean enabled = false;
+
+ /**
+ * Returns whether simple annotations are enabled.
+ * @return true if simple annotations should be used, false otherwise
+ */
+ public static boolean isEnabled() {
+ return enabled;
+ }
+
+ /**
+ * Sets whether simple annotations should be enabled.
+ * @param value true to enable simple annotations, false to disable
+ */
+ public static void setEnabled(boolean value) {
+ log.info("SimpleIndexingAnnotations enabled? " + enabled + " -> " + value);
+ enabled = value;
+ }
+
+ // Flat arrays for maximum memory density
+ private int[] positions; // [from1, len1, from2, len2, ...]
+ private String[] terms; // [term1, term2, ...] - null when term equals substring
+ private int count;
+
+ public SimpleIndexingAnnotations() {
+ this.positions = new int[32]; // Start with capacity for 16 annotations
+ this.terms = new String[16];
+ this.count = 0;
+ }
+
+ /**
+ * Add a TERM annotation.
+ *
+ * @param from the start position in the text (character offset)
+ * @param length the length of the span (in characters)
+ * @param term the term to index, or null if term equals the substring of original text
+ */
+ public void add(int from, int length, String term) {
+ ensureCapacity();
+ positions[count * 2] = from;
+ positions[count * 2 + 1] = length;
+ terms[count] = term;
+ count++;
+ }
+
+ private void ensureCapacity() {
+ if (count * 2 >= positions.length) {
+ // Grow by 2x
+ int[] newPos = new int[positions.length * 2];
+ String[] newTerms = new String[terms.length * 2];
+ System.arraycopy(positions, 0, newPos, 0, count * 2);
+ System.arraycopy(terms, 0, newTerms, 0, count);
+ positions = newPos;
+ terms = newTerms;
+ }
+ }
+
+ public int getCount() {
+ return count;
+ }
+
+ public int getFrom(int idx) {
+ return positions[idx * 2];
+ }
+
+ public int getLength(int idx) {
+ return positions[idx * 2 + 1];
+ }
+
+ /**
+ * Get the term override for annotation at index, or null if term equals substring.
+ */
+ public String getTerm(int idx) {
+ return terms[idx];
+ }
+
+ /**
+ * Convert to full SpanTree representation for API compatibility.
+ * This is only called when code actually needs to iterate over annotations,
+ * which is rare (mainly deprecated FlattenExpression and tests).
+ * Serialization uses direct path and never calls this.
+ */
+ public SpanTree toSpanTree(String name) {
+ SpanTree tree = new SpanTree(name);
+ Span currentSpan = null;
+ int currentFrom = -1;
+ int currentLength = -1;
+
+ for (int i = 0; i < count; i++) {
+ int from = getFrom(i);
+ int length = getLength(i);
+
+ // Check if this annotation is for the same span as the previous one
+ if (from != currentFrom || length != currentLength) {
+ // Different span, create a new one
+ currentSpan = tree.spanList().span(from, length);
+ currentFrom = from;
+ currentLength = length;
+ }
+ // else: same span, reuse currentSpan
+
+ String term = getTerm(i);
+ if (term != null) {
+ tree.annotate(currentSpan, new Annotation(AnnotationTypes.TERM,
+ new StringFieldValue(term)));
+ } else {
+ tree.annotate(currentSpan, new Annotation(AnnotationTypes.TERM));
+ }
+ }
+ return tree;
+ }
+
+ @Override
+ public String toString() {
+ return "SimpleIndexingAnnotations with " + count + " TERM annotations";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof SimpleIndexingAnnotations that)) return false;
+
+ if (count != that.count) return false;
+
+ // Compare the relevant portions of the arrays
+ for (int i = 0; i < count; i++) {
+ if (positions[i * 2] != that.positions[i * 2] ||
+ positions[i * 2 + 1] != that.positions[i * 2 + 1]) {
+ return false;
+ }
+ if (!java.util.Objects.equals(terms[i], that.terms[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = count;
+ for (int i = 0; i < count; i++) {
+ result = 31 * result + positions[i * 2];
+ result = 31 * result + positions[i * 2 + 1];
+ result = 31 * result + java.util.Objects.hashCode(terms[i]);
+ }
+ return result;
+ }
+}