TIKA-4875: improve tika-eval performance (#3123)

Author: tballison

CHANGES.txt

@@ -1,5 +1,13 @@
 Release 4.1.0 - unreleased
 
+   * tika-eval Profile/Compare speedups: single-pass URL/mail stripping
+     replaces the bounded regexes in langdetect preprocessing (same output,
+     17-290x faster on web text), the default H2 db URL drops MVStore chunk
+     retention and sizes the page cache at a quarter of the heap clamped to
+     [64MB, 1GB] (override with -Dtika.eval.h2.cacheSizeKb=<kb>), and the
+     status log adds a last-interval docs-per-sec rate next to the cumulative
+     average (TIKA-4875).
+     
    * New "content-enrichers" config list (TIKA-4872): select the OCR engine
      ("tesseract-ocr-parser", "tess4j-parser", "openai-vlm-parser", ...) by
      name instead of by classpath registration of the image/ocr-* pseudo

tika-eval/tika-eval-app/src/main/java/org/apache/tika/eval/app/ExtractComparerRunner.java

@@ -142,7 +142,7 @@ public static void main(String[] args) throws Exception {
         }
 
         try {
-            String jdbcString = getJdbcConnectionString(dbPath);
+            String jdbcString = JDBCUtil.getJdbcConnectionString(dbPath);
             Map<String, String> runInfo = RunInfo.evalInfo(args, evalConfig, inputDir);
             execute(inputDir, extractsADir, extractsBDir, jdbcString, evalConfig, sideA.pipesReport(), sideB.pipesReport(), runInfo, runInfoA, runInfoB);
 
@@ -177,16 +177,6 @@ private static Path optPath(CommandLine commandLine, String opt) {
         return commandLine.hasOption(opt) ? Paths.get(commandLine.getOptionValue(opt)) : null;
     }
 
-    private static String getJdbcConnectionString(String dbPath) {
-        if (dbPath.startsWith("jdbc:")) {
-            return dbPath;
-        }
-        //default to h2
-        Path p = Paths.get(dbPath);
-        return "jdbc:h2:file:" + p.toAbsolutePath();
-
-    }
-
     private static void execute(Path inputDir, Path extractsA, Path extractsB, String dbPath, EvalConfig evalConfig, PipesReport pipesReportA,
                                 PipesReport pipesReportB, Map<String, String> runInfo, Map<String, String> runInfoA, Map<String, String> runInfoB)
             throws SQLException, IOException {

tika-eval/tika-eval-app/src/main/java/org/apache/tika/eval/app/ExtractProfileRunner.java

@@ -98,7 +98,7 @@ public static void main(String[] args) throws Exception {
         Path extractsDir = commandLine.hasOption('e') ? Paths.get(commandLine.getOptionValue('e')) : Paths.get(USAGE_FAIL("Must specify extracts dir: -i"));
         Path inputDir = commandLine.hasOption('i') ? Paths.get(commandLine.getOptionValue('i')) : extractsDir;
         String dbPath = commandLine.hasOption('d') ? commandLine.getOptionValue('d') : USAGE_FAIL("Must specify the db name: -d");
-        String jdbcString = getJdbcConnectionString(dbPath);
+        String jdbcString = JDBCUtil.getJdbcConnectionString(dbPath);
         if (commandLine.hasOption('n')) {
             evalConfig.setNumWorkers(Integer.parseInt(commandLine.getOptionValue('n')));
         }
@@ -118,16 +118,6 @@ private static Path optPath(CommandLine commandLine, String opt) {
         return commandLine.hasOption(opt) ? Paths.get(commandLine.getOptionValue(opt)) : null;
     }
 
-    private static String getJdbcConnectionString(String dbPath) {
-        if (dbPath.startsWith("jdbc:")) {
-            return dbPath;
-        }
-        //default to h2
-        Path p = Paths.get(dbPath);
-        return "jdbc:h2:file:" + p.toAbsolutePath();
-
-    }
-
     private static void execute(Path inputDir, Path extractsDir, String dbPath, EvalConfig evalConfig, PipesReport pipesReport,
                                 Map<String, String> runInfo) throws SQLException, IOException {
 

tika-eval/tika-eval-app/src/main/java/org/apache/tika/eval/app/StatusReporter.java

@@ -38,6 +38,8 @@ public class StatusReporter implements Callable<Long> {
     private final AtomicBoolean crawlerIsActive;
     private final long start;
     private final NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.ROOT);
+    private int lastCnt = 0;
+    private long lastReportMillis;
 
 
     public StatusReporter(CallablePipesIterator pipesIterator, AtomicInteger filesProcessed, AtomicInteger activeWorkers, AtomicBoolean crawlerIsActive) {
@@ -46,6 +48,7 @@ public StatusReporter(CallablePipesIterator pipesIterator, AtomicInteger filesPr
         this.activeWorkers = activeWorkers;
         this.crawlerIsActive = crawlerIsActive;
         this.start = System.currentTimeMillis();
+        this.lastReportMillis = this.start;
     }
 
     @Override
@@ -68,13 +71,22 @@ public Long call() throws Exception {
     }
 
     private void report() {
+        long now = System.currentTimeMillis();
         int cnt = filesProcessed.get();
-        long elapsed = System.currentTimeMillis() - start;
+        long elapsed = now - start;
         double elapsedSecs = (double) elapsed / (double) 1000;
         int avg = (elapsedSecs > 5 || cnt > 100) ? (int) ((double) cnt / elapsedSecs) : -1;
 
-        String elapsedString = DurationFormatUtils.formatMillis(System.currentTimeMillis() - start);
-        String docsPerSec = avg > -1 ? String.format(Locale.ROOT, " (%s docs per sec)", numberFormat.format(avg)) : "";
+        // the cumulative average declines by construction and masks cliffs
+        double windowSecs = (double) (now - lastReportMillis) / (double) 1000;
+        int windowRate = windowSecs > 0 ? (int) ((double) (cnt - lastCnt) / windowSecs) : avg;
+        lastCnt = cnt;
+        lastReportMillis = now;
+
+        String elapsedString = DurationFormatUtils.formatMillis(elapsed);
+        String docsPerSec = avg > -1 ?
+                String.format(Locale.ROOT, " (%s docs per sec overall; %s in the last interval)",
+                        numberFormat.format(avg), numberFormat.format(windowRate)) : "";
         String msg = String.format(Locale.ROOT, "Processed %s documents in %s%s.", numberFormat.format(cnt), elapsedString, docsPerSec);
         LOGGER.info(msg);
 

tika-eval/tika-eval-app/src/main/java/org/apache/tika/eval/app/db/JDBCUtil.java

@@ -19,6 +19,8 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.DriverManager;
@@ -40,6 +42,17 @@
 import org.slf4j.LoggerFactory;
 
 public class JDBCUtil {
+
+    /**
+     * Override for the h2 page cache in KB; unclamped, so a big box can go well
+     * beyond the heap-relative default.
+     */
+    public static final String H2_CACHE_SIZE_KB_PROPERTY = "tika.eval.h2.cacheSizeKb";
+
+    //h2's own default: 64MB
+    private static final long MIN_H2_CACHE_SIZE_KB = 65_536L;
+    private static final long MAX_H2_CACHE_SIZE_KB = 1_048_576L;
+
     private static final Logger LOG = LoggerFactory.getLogger(JDBCUtil.class);
     private final String connectionString;
     private String driverClass;
@@ -73,6 +86,34 @@ public JDBCUtil(String connectionString, String driverClass) {
         }
     }
 
+    /**
+     * If dbPath is already a jdbc string, it is used as is; otherwise this builds the
+     * tika-eval h2 default: RETENTION_TIME=0 drops the 45s MVStore chunk retention
+     * (bloat + growing compaction cost) and CACHE_SIZE (KB) is sized by
+     * {@link #getH2CacheSizeKb()}.
+     */
+    public static String getJdbcConnectionString(String dbPath) {
+        if (dbPath.startsWith("jdbc:")) {
+            return dbPath;
+        }
+        Path p = Paths.get(dbPath);
+        return "jdbc:h2:file:" + p.toAbsolutePath() + ";RETENTION_TIME=0;CACHE_SIZE=" + getH2CacheSizeKb();
+    }
+
+    /**
+     * H2's page cache is on heap, so the default is a quarter of the heap clamped to
+     * [64MB, 1GB] rather than a fixed size that a small JVM cannot afford. Set
+     * {@value #H2_CACHE_SIZE_KB_PROPERTY} to override.
+     */
+    public static long getH2CacheSizeKb() {
+        String override = System.getProperty(H2_CACHE_SIZE_KB_PROPERTY);
+        if (override != null) {
+            return Long.parseLong(override.trim());
+        }
+        long quarterHeapKb = Runtime.getRuntime().maxMemory() / 4 / 1024;
+        return Math.min(MAX_H2_CACHE_SIZE_KB, Math.max(MIN_H2_CACHE_SIZE_KB, quarterHeapKb));
+    }
+
     public static void batchInsert(PreparedStatement insertStatement, TableInfo table, Map<Cols, String> data) throws SQLException {
 
         try {

tika-eval/tika-eval-app/src/test/java/org/apache/tika/eval/app/db/JDBCUtilTest.java

@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.tika.eval.app.db;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class JDBCUtilTest {
+
+    private String originalCacheSize;
+
+    @BeforeEach
+    public void stashCacheSizeProperty() {
+        originalCacheSize = System.getProperty(JDBCUtil.H2_CACHE_SIZE_KB_PROPERTY);
+        System.clearProperty(JDBCUtil.H2_CACHE_SIZE_KB_PROPERTY);
+    }
+
+    @AfterEach
+    public void restoreCacheSizeProperty() {
+        if (originalCacheSize == null) {
+            System.clearProperty(JDBCUtil.H2_CACHE_SIZE_KB_PROPERTY);
+        } else {
+            System.setProperty(JDBCUtil.H2_CACHE_SIZE_KB_PROPERTY, originalCacheSize);
+        }
+    }
+
+    @Test
+    public void testJdbcStringPassesThrough() {
+        String jdbc = "jdbc:postgresql://localhost/tika_eval";
+        assertEquals(jdbc, JDBCUtil.getJdbcConnectionString(jdbc));
+    }
+
+    @Test
+    public void testH2Defaults() {
+        long cacheSizeKb = JDBCUtil.getH2CacheSizeKb();
+        assertTrue(cacheSizeKb >= 65_536L && cacheSizeKb <= 1_048_576L, "clamped to [64MB, 1GB]: " + cacheSizeKb);
+        String connectionString = JDBCUtil.getJdbcConnectionString("mydb");
+        assertTrue(connectionString.startsWith("jdbc:h2:file:"), connectionString);
+        assertTrue(connectionString.endsWith(";RETENTION_TIME=0;CACHE_SIZE=" + cacheSizeKb), connectionString);
+    }
+
+    @Test
+    public void testH2CacheSizeOverrideIsUnclamped() {
+        System.setProperty(JDBCUtil.H2_CACHE_SIZE_KB_PROPERTY, "8388608");
+        assertEquals(8_388_608L, JDBCUtil.getH2CacheSizeKb());
+    }
+}