SOLR-16667

solr/core/src/java/org/apache/solr/core/SolrConfig.java

@@ -320,6 +320,9 @@ private SolrConfig(
       queryResultCacheConfig =
           CacheConfig.getConfig(
               this, get("query").get("queryResultCache"), "query/queryResultCache");
+      featureVectorCacheConfig =
+          CacheConfig.getConfig(
+              this, get("query").get("featureVectorCache"), "query/featureVectorCache");
       documentCacheConfig =
           CacheConfig.getConfig(this, get("query").get("documentCache"), "query/documentCache");
       CacheConfig conf =
@@ -709,6 +712,7 @@ public SolrRequestParsers getRequestParsers() {
   public final CacheConfig queryResultCacheConfig;
   public final CacheConfig documentCacheConfig;
   public final CacheConfig fieldValueCacheConfig;
+  public final CacheConfig featureVectorCacheConfig;
   public final Map<String, CacheConfig> userCacheConfigs;
   // SolrIndexSearcher - more...
   public final boolean useFilterForSortedQuery;
@@ -1071,7 +1075,12 @@ public Map<String, Object> toMap(Map<String, Object> result) {
     }
 
     addCacheConfig(
-        m, filterCacheConfig, queryResultCacheConfig, documentCacheConfig, fieldValueCacheConfig);
+        m,
+        filterCacheConfig,
+        queryResultCacheConfig,
+        documentCacheConfig,
+        fieldValueCacheConfig,
+        featureVectorCacheConfig);
     m = new LinkedHashMap<>();
     result.put("requestDispatcher", m);
     m.put("handleSelect", handleSelect);

solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java

@@ -152,6 +152,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
   private final SolrCache<Query, DocSet> filterCache;
   private final SolrCache<QueryResultKey, DocList> queryResultCache;
   private final SolrCache<String, UnInvertedField> fieldValueCache;
+  private final SolrCache<Integer, float[]> featureVectorCache;
   private final LongAdder fullSortCount = new LongAdder();
   private final LongAdder skipSortCount = new LongAdder();
   private final LongAdder liveDocsNaiveCacheHitCount = new LongAdder();
@@ -385,6 +386,11 @@ public SolrIndexSearcher(
               ? null
               : solrConfig.queryResultCacheConfig.newInstance();
       if (queryResultCache != null) clist.add(queryResultCache);
+      featureVectorCache =
+          solrConfig.featureVectorCacheConfig == null
+              ? null
+              : solrConfig.featureVectorCacheConfig.newInstance();
+      if (featureVectorCache != null) clist.add(featureVectorCache);
       SolrCache<Integer, Document> documentCache = docFetcher.getDocumentCache();
       if (documentCache != null) clist.add(documentCache);
 
@@ -406,6 +412,7 @@ public SolrIndexSearcher(
       this.filterCache = null;
       this.queryResultCache = null;
       this.fieldValueCache = null;
+      this.featureVectorCache = null;
       this.cacheMap = NO_GENERIC_CACHES;
       this.cacheList = NO_CACHES;
     }
@@ -622,6 +629,10 @@ public SolrCache<Query, DocSet> getFilterCache() {
     return filterCache;
   }
 
+  public SolrCache<Integer, float[]> getFeatureVectorCache() {
+    return featureVectorCache;
+  }
+
   //
   // Set default regenerators on filter and query caches if they don't have any
   //
@@ -664,6 +675,11 @@ public <K, V> boolean regenerateItem(
           });
     }
 
+    if (solrConfig.featureVectorCacheConfig != null
+        && solrConfig.featureVectorCacheConfig.getRegenerator() == null) {
+      solrConfig.featureVectorCacheConfig.setRegenerator(new NoOpRegenerator());
+    }
+
     if (solrConfig.queryResultCacheConfig != null
         && solrConfig.queryResultCacheConfig.getRegenerator() == null) {
       final int queryResultWindowSize = solrConfig.queryResultWindowSize;

solr/modules/ltr/src/java/org/apache/solr/ltr/CSVFeatureLogger.java

@@ -23,20 +23,20 @@ public class CSVFeatureLogger extends FeatureLogger {
   private final char keyValueSep;
   private final char featureSep;
 
-  public CSVFeatureLogger(String fvCacheName, FeatureFormat f) {
-    super(fvCacheName, f);
+  public CSVFeatureLogger(FeatureFormat f) {
+    super(f);
     this.keyValueSep = DEFAULT_KEY_VALUE_SEPARATOR;
     this.featureSep = DEFAULT_FEATURE_SEPARATOR;
   }
 
-  public CSVFeatureLogger(String fvCacheName, FeatureFormat f, char keyValueSep, char featureSep) {
-    super(fvCacheName, f);
+  public CSVFeatureLogger(FeatureFormat f, char keyValueSep, char featureSep) {
+    super(f);
     this.keyValueSep = keyValueSep;
     this.featureSep = featureSep;
   }
 
   @Override
-  public String makeFeatureVector(LTRScoringQuery.FeatureInfo[] featuresInfo) {
+  public String printFeatureVector(LTRScoringQuery.FeatureInfo[] featuresInfo) {
     // Allocate the buffer to a size based on the number of features instead of the
     // default 16.  You need space for the name, value, and two separators per feature,
     // but not all the features are expected to fire, so this is just a naive estimate.

solr/modules/ltr/src/java/org/apache/solr/ltr/FeatureLogger.java

@@ -16,68 +16,21 @@
  */
 package org.apache.solr.ltr;
 
-import org.apache.solr.search.SolrIndexSearcher;
-
 /**
  * FeatureLogger can be registered in a model and provide a strategy for logging the feature values.
  */
 public abstract class FeatureLogger {
 
-  /** the name of the cache using for storing the feature value */
-  private final String fvCacheName;
-
   public enum FeatureFormat {
     DENSE,
     SPARSE
   };
 
   protected final FeatureFormat featureFormat;
 
-  protected FeatureLogger(String fvCacheName, FeatureFormat f) {
-    this.fvCacheName = fvCacheName;
+  protected FeatureLogger(FeatureFormat f) {
     this.featureFormat = f;
   }
 
-  /**
-   * Log will be called every time that the model generates the feature values for a document and a
-   * query.
-   *
-   * @param docid Solr document id whose features we are saving
-   * @param featuresInfo List of all the {@link LTRScoringQuery.FeatureInfo} objects which contain
-   *     name and value for all the features triggered by the result set
-   * @return true if the logger successfully logged the features, false otherwise.
-   */
-  public boolean log(
-      int docid,
-      LTRScoringQuery scoringQuery,
-      SolrIndexSearcher searcher,
-      LTRScoringQuery.FeatureInfo[] featuresInfo) {
-    final String featureVector = makeFeatureVector(featuresInfo);
-    if (featureVector == null) {
-      return false;
-    }
-
-    if (null == searcher.cacheInsert(fvCacheName, fvCacheKey(scoringQuery, docid), featureVector)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  public abstract String makeFeatureVector(LTRScoringQuery.FeatureInfo[] featuresInfo);
-
-  private static int fvCacheKey(LTRScoringQuery scoringQuery, int docid) {
-    return scoringQuery.hashCode() + (31 * docid);
-  }
-
-  /**
-   * populate the document with its feature vector
-   *
-   * @param docid Solr document id
-   * @return String representation of the list of features calculated for docid
-   */
-  public String getFeatureVector(
-      int docid, LTRScoringQuery scoringQuery, SolrIndexSearcher searcher) {
-    return (String) searcher.cacheLookup(fvCacheName, fvCacheKey(scoringQuery, docid));
-  }
+  public abstract String printFeatureVector(LTRScoringQuery.FeatureInfo[] featuresInfo);
 }

solr/modules/ltr/src/java/org/apache/solr/ltr/LTRRescorer.java

@@ -31,7 +31,6 @@
 import org.apache.lucene.search.TotalHits;
 import org.apache.lucene.search.Weight;
 import org.apache.solr.ltr.interleaving.OriginalRankingLTRScoringQuery;
-import org.apache.solr.search.SolrIndexSearcher;
 
 /**
  * Implements the rescoring logic. The top documents returned by solr with their original scores,
@@ -136,7 +135,7 @@ private ScoreDoc[] rerank(IndexSearcher searcher, int topN, ScoreDoc[] firstPass
         (LTRScoringQuery.ModelWeight)
             searcher.createWeight(searcher.rewrite(scoringQuery), ScoreMode.COMPLETE, 1);
 
-    scoreFeatures(searcher, topN, modelWeight, firstPassResults, leaves, reranked);
+    scoreFeatures(topN, modelWeight, firstPassResults, leaves, reranked);
     // Must sort all documents that we reranked, and then select the top
     Arrays.sort(reranked, scoreComparator);
     return reranked;
@@ -151,7 +150,6 @@ protected static ScoreDoc[] getFirstPassDocsRanked(TopDocs firstPassTopDocs) {
   }
 
   public void scoreFeatures(
-      IndexSearcher indexSearcher,
       int topN,
       LTRScoringQuery.ModelWeight modelWeight,
       ScoreDoc[] hits,
@@ -180,36 +178,13 @@ public void scoreFeatures(
         docBase = readerContext.docBase;
         scorer = modelWeight.scorer(readerContext);
       }
-      if (scoreSingleHit(topN, docBase, hitUpto, hit, docID, scorer, reranked)) {
-        logSingleHit(indexSearcher, modelWeight, hit.doc, scoringQuery);
-      }
+      scoreSingleHit(topN, docBase, hitUpto, hit, docID, scorer, reranked);
       hitUpto++;
     }
   }
 
-  /**
-   * Call this method if the {@link #scoreSingleHit(int, int, int, ScoreDoc, int,
-   * org.apache.solr.ltr.LTRScoringQuery.ModelWeight.ModelScorer, ScoreDoc[])} method indicated that
-   * the document's feature info should be logged.
-   */
-  protected static void logSingleHit(
-      IndexSearcher indexSearcher,
-      LTRScoringQuery.ModelWeight modelWeight,
-      int docid,
-      LTRScoringQuery scoringQuery) {
-    final FeatureLogger featureLogger = scoringQuery.getFeatureLogger();
-    if (featureLogger != null && indexSearcher instanceof SolrIndexSearcher) {
-      featureLogger.log(
-          docid, scoringQuery, (SolrIndexSearcher) indexSearcher, modelWeight.getFeaturesInfo());
-    }
-  }
-
-  /**
-   * Scores a single document and returns true if the document's feature info should be logged via
-   * the {@link #logSingleHit(IndexSearcher, org.apache.solr.ltr.LTRScoringQuery.ModelWeight, int,
-   * LTRScoringQuery)} method. Feature info logging is only necessary for the topN documents.
-   */
-  protected static boolean scoreSingleHit(
+  /** Scores a single document. */
+  protected static void scoreSingleHit(
       int topN,
       int docBase,
       int hitUpto,
@@ -230,32 +205,23 @@ protected static boolean scoreSingleHit(
     scorer.docID();
     scorer.iterator().advance(targetDoc);
 
-    boolean logHit = false;
-
     scorer.getDocInfo().setOriginalDocScore(hit.score);
     hit.score = scorer.score();
     if (hitUpto < topN) {
       reranked[hitUpto] = hit;
-      // if the heap is not full, maybe I want to log the features for this
-      // document
-      logHit = true;
     } else if (hitUpto == topN) {
       // collected topN document, I create the heap
       heapify(reranked, topN);
     }
     if (hitUpto >= topN) {
-      // once that heap is ready, if the score of this document is lower that
-      // the minimum
-      // i don't want to log the feature. Otherwise I replace it with the
-      // minimum and fix the
-      // heap.
+      // once that heap is ready, if the score of this document is greater that
+      // the minimum I replace it with the
+      // minimum and fix the heap.
       if (hit.score > reranked[0].score) {
         reranked[0] = hit;
         heapAdjust(reranked, topN, 0);
-        logHit = true;
       }
     }
-    return logHit;
   }
 
   @Override