From c528cdd5c3186628c45aa06e9939d328b5e0796a Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Sun, 25 Aug 2024 17:39:01 -0400 Subject: [PATCH 01/25] Additional JMH tests --- compliance/repository/pom.xml | 12 ++++++ ...sitoryFederatedServiceIntegrationTest.java | 31 +++++++++++++- .../impl/MinimalContextNowTest.java | 29 +++++++++++++- .../rdf4j/sail/helpers/AbstractSailTest.java | 30 +++++++++++++- core/sail/lucene/pom.xml | 12 ++++++ .../impl/AbstractGenericLuceneTest.java | 31 +++++++++++++- .../memory/model/MemStatementListTestIT.java | 31 +++++++++++++- .../rdf4j/sail/shacl/MultithreadedTest.java | 40 +++++++++++++++++-- 8 files changed, 205 insertions(+), 11 deletions(-) diff --git a/compliance/repository/pom.xml b/compliance/repository/pom.xml index b5e75f0c7b3..95e48a074a7 100644 --- a/compliance/repository/pom.xml +++ b/compliance/repository/pom.xml @@ -50,6 +50,18 @@ ${project.version} war + + org.openjdk.jmh + jmh-core + ${jmhVersion} + test + + + org.openjdk.jmh + jmh-generator-annprocess + ${jmhVersion} + test + diff --git a/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java b/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java index 763d3c2a6d2..79817aa99ab 100644 --- a/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java +++ b/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java @@ -39,6 +39,23 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; import com.google.common.collect.Lists; @@ -47,8 +64,17 @@ * * @author Andreas Schwarte */ +@State(Scope.Benchmark) +@Warmup(iterations = 5) +@BenchmarkMode({ Mode.AverageTime }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.MILLISECONDS) public class RepositoryFederatedServiceIntegrationTest { + @Param({ "10", "50", "100", "500", "1000", "5000" }) + private int numThreads; + private static final ValueFactory vf = SimpleValueFactory.getInstance(); private SailRepository serviceRepo; @@ -56,6 +82,7 @@ public class RepositoryFederatedServiceIntegrationTest { private RepositoryFederatedService federatedService; @BeforeEach + @Setup(Level.Iteration) public void before() { serviceRepo = new SailRepository(new MemoryStore()); serviceRepo.init(); @@ -74,6 +101,7 @@ public FederatedService getService(String serviceUrl) throws QueryEvaluationExce } @AfterEach + @TearDown((Level.Iteration)) public void after() { federatedService.shutdown(); localRepo.shutDown(); @@ -277,6 +305,7 @@ public void test8a_subSelectAll() { } @Test + @Benchmark public void test9_connectionHandling() throws Exception { /* @@ -297,7 +326,7 @@ public void test9_connectionHandling() throws Exception { ExecutorService executor = Executors.newFixedThreadPool(5); try { - for (int i = 0; i < 5; i++) { + for (int i = 0; i < numThreads; i++) { executor.submit(() -> { String query = "SELECT ?var WHERE { SERVICE { ?s ?p ?var } }"; diff --git a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java index a4d5af4ebb5..a7bdbbe674d 100644 --- a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java +++ b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java @@ -16,6 +16,7 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; import java.util.stream.IntStream; @@ -26,9 +27,33 @@ import org.eclipse.rdf4j.query.impl.EmptyBindingSet; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; - +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +@State(Scope.Benchmark) +@Warmup(iterations = 5) +@BenchmarkMode({ Mode.AverageTime }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.MILLISECONDS) public class MinimalContextNowTest { + @Param({ "10", "50", "100", "500", "1000", "5000" }) + private int numberOfThreads; + @Test public void testNow() { // Tests that the now value is correctly initialized. @@ -45,9 +70,9 @@ public void testNow() { } @Test + @Benchmark public void testConcurrentAccessToNow() throws ExecutionException, InterruptedException { int numberOfIterations = 100; - int numberOfThreads = 10; ExecutorService executorService = Executors.newCachedThreadPool(); try { diff --git a/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java b/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java index c1c64931f40..1e957192e9c 100644 --- a/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java +++ b/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java @@ -25,19 +25,45 @@ import org.eclipse.rdf4j.sail.SailException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; - /** * Unit tests for {@link AbstractSail}. * * @author Jeen Broekstra */ +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +@State(Scope.Benchmark) +@Warmup(iterations = 5) +@BenchmarkMode({ Mode.AverageTime }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.MILLISECONDS) public class AbstractSailTest { + @Param({ "10", "50", "100", "500", "1000", "5000" }) + private int count; + AbstractSail subject; private final Random random = new Random(43252333); @BeforeEach + @Setup(Level.Iteration) public void setUp() { subject = new AbstractSail() { @@ -96,8 +122,8 @@ public void testExplicitInitTwice() { } @Test + @Benchmark public void testConcurrentAutoInit() throws Exception { - int count = 200; CountDownLatch latch = new CountDownLatch(count); for (int i = 0; i < count; i++) { diff --git a/core/sail/lucene/pom.xml b/core/sail/lucene/pom.xml index a0e0c7f070f..c9252913b63 100644 --- a/core/sail/lucene/pom.xml +++ b/core/sail/lucene/pom.xml @@ -78,5 +78,17 @@ junit-vintage-engine test + + org.openjdk.jmh + jmh-core + ${jmhVersion} + test + + + org.openjdk.jmh + jmh-generator-annprocess + ${jmhVersion} + test + diff --git a/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java b/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java index 1e09c30169e..b3f574e0bfa 100644 --- a/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java +++ b/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java @@ -67,11 +67,38 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @Timeout(value = 10, unit = TimeUnit.MINUTES) +@State(Scope.Benchmark) +@Warmup(iterations = 5) +@BenchmarkMode({ Mode.AverageTime }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.MILLISECONDS) public abstract class AbstractGenericLuceneTest { + + @Param({ "10", "50", "100", "500", "1000", "5000" }) + int numThreads; + protected static final ValueFactory vf = SimpleValueFactory.getInstance(); public static final String QUERY_STRING; @@ -120,6 +147,7 @@ public abstract class AbstractGenericLuceneTest { protected abstract void configure(LuceneSail sail) throws IOException; @BeforeEach + @Setup(Level.Iteration) public void setUp() throws Exception { // set logging, uncomment this to get better logging for debugging // org.apache.log4j.BasicConfigurator.configure(); @@ -151,6 +179,7 @@ public void setUp() throws Exception { } @AfterEach + @TearDown(Level.Iteration) public void tearDown() throws RepositoryException { try { if (connection != null) { @@ -767,8 +796,8 @@ public void testPropertyVar() throws MalformedQueryException, RepositoryExceptio } @Test + @Benchmark public void testMultithreadedAdd() throws InterruptedException { - int numThreads = 3; final CountDownLatch startLatch = new CountDownLatch(1); final CountDownLatch endLatch = new CountDownLatch(numThreads); final Set exceptions = ConcurrentHashMap.newKeySet(); diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java index c8594d67184..c61068eec85 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java @@ -31,6 +31,7 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -47,16 +48,41 @@ import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; import com.google.common.collect.Lists; @Tag("slow") +@State(Scope.Benchmark) +@Warmup(iterations = 5) +@BenchmarkMode({ Mode.AverageTime }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.MILLISECONDS) public class MemStatementListTestIT { private static List statements; - public static final int CHUNKS = 1_000; + + @Param({ "10", "50", "100", "500", "1000", "5000" }) + public static int CHUNKS; @BeforeAll + @Setup(Level.Trial) public static void beforeAll() throws IOException { MemoryStore memoryStore = new MemoryStore(); try { @@ -91,6 +117,7 @@ public static void beforeAll() throws IOException { } @BeforeEach + @Setup(Level.Iteration) public void beforeEach() { for (MemStatement statement : statements) { statement.setTillSnapshot(Integer.MAX_VALUE); @@ -100,6 +127,7 @@ public void beforeEach() { @Test @Timeout(120) + @Benchmark public void addMultipleThreads() throws ExecutionException, InterruptedException { List> partition = Lists.partition(statements, CHUNKS); @@ -140,6 +168,7 @@ public void addMultipleThreads() throws ExecutionException, InterruptedException @Test @Timeout(120) + @Benchmark public void addMultipleThreadsAndCleanupThread() throws ExecutionException, InterruptedException { List> partition = Lists.partition(statements, CHUNKS); diff --git a/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java b/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java index 89aea92cac9..1eaa6363551 100644 --- a/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java +++ b/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java @@ -10,6 +10,8 @@ *******************************************************************************/ package org.eclipse.rdf4j.sail.shacl; +import static org.openjdk.jmh.annotations.Level.Trial; + import java.io.IOException; import java.io.InputStream; import java.io.StringReader; @@ -47,26 +49,55 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.parallel.Isolated; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; import org.slf4j.LoggerFactory; import ch.qos.logback.classic.Level; import ch.qos.logback.classic.Logger; @Isolated +@State(Scope.Benchmark) +@Warmup(iterations = 5) +@BenchmarkMode({ Mode.AverageTime }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Measurement(iterations = 5) +@OutputTimeUnit(TimeUnit.MILLISECONDS) public abstract class MultithreadedTest { + + @Param({ "1", "5", "10", "50", "100" }) + private int numThreadsPerTransaction; + SimpleValueFactory vf = SimpleValueFactory.getInstance(); @BeforeAll + @Setup(org.openjdk.jmh.annotations.Level.Trial) public static void beforeAll() { ParentReferenceChecker.skip = true; } @AfterAll + @TearDown(org.openjdk.jmh.annotations.Level.Trial) public static void afterAll() { ParentReferenceChecker.skip = false; } @Test + @Benchmark public void testDataAndShapes() { System.out.println("testDataAndShapes"); @@ -211,7 +242,7 @@ public void testDataAndShapes() { } - private void parallelTest(List> list, IsolationLevels isolationLevel) { + public void parallelTest(List> list, IsolationLevels isolationLevel) { ShaclSail sail = new ShaclSail(getBaseSail()); sail.setParallelValidation(true); sail.setLogValidationPlans(false); @@ -226,7 +257,7 @@ private void parallelTest(List> list, IsolationLevels isolatio ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2); try { - for (int i = 0; i < 3; i++) { + for (int i = 0; i < numThreadsPerTransaction; i++) { list.stream() .flatMap(Collection::stream) .sorted(Comparator.comparingInt(System::identityHashCode)) @@ -357,7 +388,7 @@ public void testLotsOfValidationFailuresSnapshot() throws IOException { public void testLotsOfValidationFailuresSerializableValidation() throws IOException { System.out.println("testLotsOfValidationFailuresSerializableValidation"); Logger root = (Logger) LoggerFactory.getLogger(ShaclSailBaseConfiguration.class.getName()); - root.setLevel(Level.ERROR); + root.setLevel(ch.qos.logback.classic.Level.ERROR); ShaclSail sail = new ShaclSail(getBaseSail()); @@ -374,7 +405,8 @@ public void testLotsOfValidationFailuresSerializableValidation() throws IOExcept public void testLotsOfValidationFailuresSerializable() throws IOException { System.out.println("testLotsOfValidationFailuresSerializable"); - ((Logger) LoggerFactory.getLogger(ShaclSailConnection.class.getName())).setLevel(Level.ERROR); + ((Logger) LoggerFactory.getLogger(ShaclSailConnection.class.getName())) + .setLevel(ch.qos.logback.classic.Level.ERROR); ShaclSail sail = new ShaclSail(getBaseSail()); From 151c708639b3fc4c79eb6db8ccc300938c065398 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Sun, 25 Aug 2024 18:28:02 -0400 Subject: [PATCH 02/25] Update MemStatementListTestIT.java --- .../rdf4j/sail/memory/model/MemStatementListTestIT.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java index c61068eec85..00b6701ca3b 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java @@ -79,11 +79,14 @@ public class MemStatementListTestIT { private static List statements; @Param({ "10", "50", "100", "500", "1000", "5000" }) - public static int CHUNKS; + public static int CHUNKS = 1_000; @BeforeAll @Setup(Level.Trial) public static void beforeAll() throws IOException { + boolean isJmhRunning = System.getProperty("jmh.ignoreLock") != null; + if (!isJmhRunning) + CHUNKS = 1_000; MemoryStore memoryStore = new MemoryStore(); try { try (NotifyingSailConnection connection = memoryStore.getConnection()) { From 23a7261dff8685c9085d72c2e4522b26855dac41 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Sun, 25 Aug 2024 18:33:29 -0400 Subject: [PATCH 03/25] Update pr-verify.yml --- .github/workflows/pr-verify.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr-verify.yml b/.github/workflows/pr-verify.yml index 01c76a7fb97..305355e3e6a 100644 --- a/.github/workflows/pr-verify.yml +++ b/.github/workflows/pr-verify.yml @@ -92,7 +92,7 @@ jobs: - name: Build run: mvn -B -U -T 2 clean install -Pquick,-formatting -Dmaven.javadoc.skip=true -Djapicmp.skip -Denforcer.skip=true -Danimal.sniffer.skip=true - name: Verify - run: mvn -B verify -PslowTestsOnly,-skipSlowTests,-formatting -Dmaven.javadoc.skip=true -Djapicmp.skip -Denforcer.skip=true -Danimal.sniffer.skip=true + run: mvn -B verify -PslowTestsOnly,-skipSlowTests,-formatting -Dmaven.javadoc.skip=true -Djapicmp.skip -Denforcer.skip=true -Danimal.sniffer.skip=true -Djmh.skip=true - name: Publish Test Report if: failure() uses: scacap/action-surefire-report@v1 From 6070d3840dc13d971596a0ec7c097d94bc2331b7 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Sun, 25 Aug 2024 18:49:02 -0400 Subject: [PATCH 04/25] Update pr-verify.yml --- .github/workflows/pr-verify.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr-verify.yml b/.github/workflows/pr-verify.yml index 305355e3e6a..01c76a7fb97 100644 --- a/.github/workflows/pr-verify.yml +++ b/.github/workflows/pr-verify.yml @@ -92,7 +92,7 @@ jobs: - name: Build run: mvn -B -U -T 2 clean install -Pquick,-formatting -Dmaven.javadoc.skip=true -Djapicmp.skip -Denforcer.skip=true -Danimal.sniffer.skip=true - name: Verify - run: mvn -B verify -PslowTestsOnly,-skipSlowTests,-formatting -Dmaven.javadoc.skip=true -Djapicmp.skip -Denforcer.skip=true -Danimal.sniffer.skip=true -Djmh.skip=true + run: mvn -B verify -PslowTestsOnly,-skipSlowTests,-formatting -Dmaven.javadoc.skip=true -Djapicmp.skip -Denforcer.skip=true -Danimal.sniffer.skip=true - name: Publish Test Report if: failure() uses: scacap/action-surefire-report@v1 From 34a102f6f2390014e6446e06ddeff61e7c03b803 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 18:47:10 -0400 Subject: [PATCH 05/25] Update MultithreadedTest.java --- .../rdf4j/sail/shacl/MultithreadedTest.java | 40 ++----------------- 1 file changed, 4 insertions(+), 36 deletions(-) diff --git a/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java b/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java index 1eaa6363551..89aea92cac9 100644 --- a/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java +++ b/core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/MultithreadedTest.java @@ -10,8 +10,6 @@ *******************************************************************************/ package org.eclipse.rdf4j.sail.shacl; -import static org.openjdk.jmh.annotations.Level.Trial; - import java.io.IOException; import java.io.InputStream; import java.io.StringReader; @@ -49,55 +47,26 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.parallel.Isolated; -import org.openjdk.jmh.annotations.Benchmark; -import org.openjdk.jmh.annotations.BenchmarkMode; -import org.openjdk.jmh.annotations.Fork; -import org.openjdk.jmh.annotations.Measurement; -import org.openjdk.jmh.annotations.Mode; -import org.openjdk.jmh.annotations.OutputTimeUnit; -import org.openjdk.jmh.annotations.Param; -import org.openjdk.jmh.annotations.Scope; -import org.openjdk.jmh.annotations.Setup; -import org.openjdk.jmh.annotations.State; -import org.openjdk.jmh.annotations.TearDown; -import org.openjdk.jmh.annotations.Warmup; -import org.openjdk.jmh.runner.Runner; -import org.openjdk.jmh.runner.RunnerException; -import org.openjdk.jmh.runner.options.Options; -import org.openjdk.jmh.runner.options.OptionsBuilder; import org.slf4j.LoggerFactory; import ch.qos.logback.classic.Level; import ch.qos.logback.classic.Logger; @Isolated -@State(Scope.Benchmark) -@Warmup(iterations = 5) -@BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) -@Measurement(iterations = 5) -@OutputTimeUnit(TimeUnit.MILLISECONDS) public abstract class MultithreadedTest { - - @Param({ "1", "5", "10", "50", "100" }) - private int numThreadsPerTransaction; - SimpleValueFactory vf = SimpleValueFactory.getInstance(); @BeforeAll - @Setup(org.openjdk.jmh.annotations.Level.Trial) public static void beforeAll() { ParentReferenceChecker.skip = true; } @AfterAll - @TearDown(org.openjdk.jmh.annotations.Level.Trial) public static void afterAll() { ParentReferenceChecker.skip = false; } @Test - @Benchmark public void testDataAndShapes() { System.out.println("testDataAndShapes"); @@ -242,7 +211,7 @@ public void testDataAndShapes() { } - public void parallelTest(List> list, IsolationLevels isolationLevel) { + private void parallelTest(List> list, IsolationLevels isolationLevel) { ShaclSail sail = new ShaclSail(getBaseSail()); sail.setParallelValidation(true); sail.setLogValidationPlans(false); @@ -257,7 +226,7 @@ public void parallelTest(List> list, IsolationLevels isolation ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2); try { - for (int i = 0; i < numThreadsPerTransaction; i++) { + for (int i = 0; i < 3; i++) { list.stream() .flatMap(Collection::stream) .sorted(Comparator.comparingInt(System::identityHashCode)) @@ -388,7 +357,7 @@ public void testLotsOfValidationFailuresSnapshot() throws IOException { public void testLotsOfValidationFailuresSerializableValidation() throws IOException { System.out.println("testLotsOfValidationFailuresSerializableValidation"); Logger root = (Logger) LoggerFactory.getLogger(ShaclSailBaseConfiguration.class.getName()); - root.setLevel(ch.qos.logback.classic.Level.ERROR); + root.setLevel(Level.ERROR); ShaclSail sail = new ShaclSail(getBaseSail()); @@ -405,8 +374,7 @@ public void testLotsOfValidationFailuresSerializableValidation() throws IOExcept public void testLotsOfValidationFailuresSerializable() throws IOException { System.out.println("testLotsOfValidationFailuresSerializable"); - ((Logger) LoggerFactory.getLogger(ShaclSailConnection.class.getName())) - .setLevel(ch.qos.logback.classic.Level.ERROR); + ((Logger) LoggerFactory.getLogger(ShaclSailConnection.class.getName())).setLevel(Level.ERROR); ShaclSail sail = new ShaclSail(getBaseSail()); From 21f9f259e113ecf7d78f47ae293629510827afd7 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 23:04:23 -0400 Subject: [PATCH 06/25] Add Param annotations to relevant existing benchmarks --- .../ReadWriteLockManagerBenchmark.java | 14 +++++++++----- .../benchmark/OverflowBenchmarkConcurrent.java | 6 +++++- .../benchmark/ConcurrentQueryBenchmark.java | 12 ++++++++---- .../MemValueFactoryConcurrentBenchmark.java | 10 +++++++--- .../ParallelMixedReadWriteBenchmark.java | 18 +++++++++++------- .../benchmark/ParallelQueryBenchmark.java | 16 ++++++++++------ .../benchmark/OverflowBenchmarkConcurrent.java | 6 +++++- 7 files changed, 55 insertions(+), 27 deletions(-) diff --git a/core/sail/api/src/test/java/org/eclipse/rdf4j/common/concurrent/locks/benchmarks/ReadWriteLockManagerBenchmark.java b/core/sail/api/src/test/java/org/eclipse/rdf4j/common/concurrent/locks/benchmarks/ReadWriteLockManagerBenchmark.java index e9f5542be69..93383f868a7 100644 --- a/core/sail/api/src/test/java/org/eclipse/rdf4j/common/concurrent/locks/benchmarks/ReadWriteLockManagerBenchmark.java +++ b/core/sail/api/src/test/java/org/eclipse/rdf4j/common/concurrent/locks/benchmarks/ReadWriteLockManagerBenchmark.java @@ -24,6 +24,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Warmup; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.Runner; @@ -41,6 +42,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ReadWriteLockManagerBenchmark extends BaseLockManagerBenchmark { + @Param({ "10", "50", "100", "500", "1000", "5000" }) + public int numThreads; + public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder().include("ReadWriteLockManagerBenchmark.*") // adapt to run other benchmark // tests @@ -58,7 +62,7 @@ public void onlyReadLocksNoContention(Blackhole blackhole) throws Exception { AbstractReadWriteLockManager lockManager = getReadWriteLockManager(); - threads(100, () -> { + threads(numThreads, () -> { readLocks(lockManager, 100, blackhole); @@ -71,7 +75,7 @@ public void onlyWriteLocks(Blackhole blackhole) throws Exception { AbstractReadWriteLockManager lockManager = getReadWriteLockManager(); - threads(1000, () -> { + threads(numThreads, () -> { try { Lock lock = lockManager.getWriteLock(); lock.release(); @@ -94,7 +98,7 @@ public void mixedReadHeavy(Blackhole blackhole) throws Exception { AbstractReadWriteLockManager lockManager = getReadWriteLockManager(); - threads(100, () -> { + threads(numThreads, () -> { try { Lock lock = lockManager.getWriteLock(); lock.release(); @@ -115,7 +119,7 @@ public void readPriority(Blackhole blackhole) throws Exception { AbstractReadWriteLockManager lockManager = getReadWriteLockManager(); - threads(100, () -> { + threads(numThreads, () -> { try { Lock readLock1 = lockManager.getReadLock(); @@ -190,7 +194,7 @@ public void mixed(Blackhole blackhole) throws Exception { AbstractReadWriteLockManager lockManager = getReadWriteLockManager(); - threads(1000, () -> { + threads(numThreads, () -> { try { Lock lock = lockManager.getWriteLock(); lock.release(); diff --git a/core/sail/lmdb/src/test/java/org/eclipse/rdf4j/sail/lmdb/benchmark/OverflowBenchmarkConcurrent.java b/core/sail/lmdb/src/test/java/org/eclipse/rdf4j/sail/lmdb/benchmark/OverflowBenchmarkConcurrent.java index eef34f93d1c..024bb8c84c1 100644 --- a/core/sail/lmdb/src/test/java/org/eclipse/rdf4j/sail/lmdb/benchmark/OverflowBenchmarkConcurrent.java +++ b/core/sail/lmdb/src/test/java/org/eclipse/rdf4j/sail/lmdb/benchmark/OverflowBenchmarkConcurrent.java @@ -54,6 +54,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -78,6 +79,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class OverflowBenchmarkConcurrent { + @Param({ "5", "25", "50", "250", "500", "2500" }) + public int numThreadsHalf; + @Setup(Level.Trial) public void setup() { ((Logger) (LoggerFactory @@ -123,7 +127,7 @@ public void manyConcurrentTransactions() throws IOException { CountDownLatch countDownLatch = new CountDownLatch(1); - for (int i = 0; i < 38; i++) { + for (int i = 0; i < numThreadsHalf; i++) { var seed = i + 485924; { Future submit = executorService.submit(() -> { diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java index 1785a1f7352..5f842f36aac 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java @@ -25,6 +25,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -47,6 +48,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ConcurrentQueryBenchmark extends BaseConcurrentBenchmark { + @Param({ "10", "50", "100", "500", "1000", "5000" }) + public int numThreads; + private SailRepository repository; public static void main(String[] args) throws RunnerException { @@ -82,7 +86,7 @@ public void tearDown() throws Exception { @Benchmark public void hasStatement(Blackhole blackhole) throws Exception { - threads(100, () -> { + threads(numThreads, () -> { try (SailRepositoryConnection connection = repository.getConnection()) { for (int i = 0; i < 100; i++) { boolean b = connection.hasStatement(null, null, null, true); @@ -95,7 +99,7 @@ public void hasStatement(Blackhole blackhole) throws Exception { @Benchmark public void hasStatementSharedConnection(Blackhole blackhole) throws Exception { try (SailRepositoryConnection connection = repository.getConnection()) { - threads(100, () -> { + threads(numThreads, () -> { for (int i = 0; i < 100; i++) { boolean b = connection.hasStatement(null, null, null, true); blackhole.consume(b); @@ -106,7 +110,7 @@ public void hasStatementSharedConnection(Blackhole blackhole) throws Exception { @Benchmark public void getNamespaces(Blackhole blackhole) throws Exception { - threads(100, () -> { + threads(numThreads, () -> { try (SailRepositoryConnection connection = repository.getConnection()) { for (int i = 0; i < 100; i++) { blackhole.consume(connection.getNamespaces().stream().count()); @@ -118,7 +122,7 @@ public void getNamespaces(Blackhole blackhole) throws Exception { @Benchmark public void getNamespacesSharedConnection(Blackhole blackhole) throws Exception { try (SailRepositoryConnection connection = repository.getConnection()) { - threads(100, () -> { + threads(numThreads, () -> { for (int i = 0; i < 100; i++) { blackhole.consume(connection.getNamespaces().stream().count()); } diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java index 4f5b02057cb..58fd3b640c7 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java @@ -38,6 +38,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -62,6 +63,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class MemValueFactoryConcurrentBenchmark extends BaseConcurrentBenchmark { + @Param({ "10", "50", "100", "500", "1000", "5000" }) + public int numThreads; + public static final int BUCKET_SIZE = 10000; private SailRepository repository; private List> values; @@ -129,7 +133,7 @@ public void onlyReads(Blackhole blackhole) throws Exception { Random random = new Random(48593); - threads(100, () -> { + threads(numThreads, () -> { List values = this.values.get(random.nextInt(this.values.size())); @@ -151,7 +155,7 @@ public void readHeavy(Blackhole blackhole) throws Exception { Random random = new Random(48593); - threads(100, () -> { + threads(numThreads, () -> { Random r = new Random(random.nextInt()); for (int i = 0; i < BUCKET_SIZE; i++) { MemIRI orCreateMemURI = valueFactory @@ -171,7 +175,7 @@ public void onlyWrites(Blackhole blackhole) throws Exception { AtomicInteger atomicInteger = new AtomicInteger(); - threads(100, () -> { + threads(numThreads, () -> { int base = atomicInteger.incrementAndGet(); for (int i = 0; i < BUCKET_SIZE; i++) { IRI iri = valueFactory.createIRI("http://example.com", base + "-" + i); diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java index 3e1bae0270c..9b9a2fa7c17 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java @@ -45,6 +45,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -73,6 +74,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ParallelMixedReadWriteBenchmark extends BaseConcurrentBenchmark { + @Param({ "1", "5", "10", "50", "100", "500" }) + public int workloadSize; + private static final String query1; private static final String query4; private static final String query7_pathexpression1; @@ -181,7 +185,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch RepositoryConnection connection, IsolationLevel isolationLevel) { ArrayList list = new ArrayList<>(); - for (int i = 0; i < 10; i++) { + for (int i = 0; i < workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query4) @@ -195,7 +199,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 30; i++) { + for (int i = 0; i < 3*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query7_pathexpression1) @@ -209,7 +213,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 30; i++) { + for (int i = 0; i < 3*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query8_pathexpression2) @@ -223,7 +227,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 400; i++) { + for (int i = 0; i < 40*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, false)); // System.out.println("Finished hasStatement explicit"); @@ -231,7 +235,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 400; i++) { + for (int i = 0; i < 40*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, true)); // System.out.println("Finished hasStatement inferred"); @@ -239,7 +243,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 20; i++) { + for (int i = 0; i < 2*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query1) @@ -252,7 +256,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 200; i++) { + for (int i = 0; i < 20*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { for (int j = 0; j < 100; j++) { localConnection.add(Values.bnode(), RDFS.LABEL, Values.literal(j), diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java index d5dfcafd320..6fc0a600a12 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java @@ -39,6 +39,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -58,6 +59,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ParallelQueryBenchmark extends BaseConcurrentBenchmark { + @Param({ "1", "5", "10", "50", "100", "500" }) + public int workloadSize; + private static final String query1; private static final String query4; private static final String query7_pathexpression1; @@ -133,7 +137,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch RepositoryConnection connection, IsolationLevel isolationLevel) { ArrayList list = new ArrayList<>(); - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 2*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query4) @@ -145,7 +149,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 2*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query7_pathexpression1) @@ -157,7 +161,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 2*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query8_pathexpression2) @@ -169,19 +173,19 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 20*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, false)); })); } - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 20*workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, true)); })); } - for (int i = 0; i < 5; i++) { + for (int i = 0; i < workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query1) diff --git a/core/sail/nativerdf/src/test/java/org/eclipse/rdf4j/sail/nativerdf/benchmark/OverflowBenchmarkConcurrent.java b/core/sail/nativerdf/src/test/java/org/eclipse/rdf4j/sail/nativerdf/benchmark/OverflowBenchmarkConcurrent.java index 277c6c498ec..bd3759639a8 100644 --- a/core/sail/nativerdf/src/test/java/org/eclipse/rdf4j/sail/nativerdf/benchmark/OverflowBenchmarkConcurrent.java +++ b/core/sail/nativerdf/src/test/java/org/eclipse/rdf4j/sail/nativerdf/benchmark/OverflowBenchmarkConcurrent.java @@ -53,6 +53,7 @@ import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -76,6 +77,9 @@ @OutputTimeUnit(TimeUnit.MILLISECONDS) public class OverflowBenchmarkConcurrent { + @Param({ "5", "25", "50", "250", "500", "2500" }) + public int numThreadsHalf; + @Setup(Level.Trial) public void setup() { ((Logger) (LoggerFactory @@ -115,7 +119,7 @@ public void manyConcurrentTransactions() throws IOException { CountDownLatch countDownLatch = new CountDownLatch(1); - for (int i = 0; i < 38; i++) { + for (int i = 0; i < numThreadsHalf; i++) { var seed = i + 485924; { Future submit = executorService.submit(() -> { From 4e415254369a75a973c7c6d9454515ce5c488927 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 23:18:05 -0400 Subject: [PATCH 07/25] Format --- .../benchmark/ParallelMixedReadWriteBenchmark.java | 12 ++++++------ .../memory/benchmark/ParallelQueryBenchmark.java | 10 +++++----- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java index 9b9a2fa7c17..b7a2f0aedd5 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java @@ -199,7 +199,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 3*workloadSize; i++) { + for (int i = 0; i < 3 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query7_pathexpression1) @@ -213,7 +213,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 3*workloadSize; i++) { + for (int i = 0; i < 3 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query8_pathexpression2) @@ -227,7 +227,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 40*workloadSize; i++) { + for (int i = 0; i < 40 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, false)); // System.out.println("Finished hasStatement explicit"); @@ -235,7 +235,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 40*workloadSize; i++) { + for (int i = 0; i < 40 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, true)); // System.out.println("Finished hasStatement inferred"); @@ -243,7 +243,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 2*workloadSize; i++) { + for (int i = 0; i < 2 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query1) @@ -256,7 +256,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 20*workloadSize; i++) { + for (int i = 0; i < 20 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { for (int j = 0; j < 100; j++) { localConnection.add(Values.bnode(), RDFS.LABEL, Values.literal(j), diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java index 6fc0a600a12..e972eea0d11 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java @@ -137,7 +137,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch RepositoryConnection connection, IsolationLevel isolationLevel) { ArrayList list = new ArrayList<>(); - for (int i = 0; i < 2*workloadSize; i++) { + for (int i = 0; i < 2 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query4) @@ -149,7 +149,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 2*workloadSize; i++) { + for (int i = 0; i < 2 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query7_pathexpression1) @@ -161,7 +161,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 2*workloadSize; i++) { + for (int i = 0; i < 2 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { long count = localConnection .prepareTupleQuery(query8_pathexpression2) @@ -173,13 +173,13 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch })); } - for (int i = 0; i < 20*workloadSize; i++) { + for (int i = 0; i < 20 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, false)); })); } - for (int i = 0; i < 20*workloadSize; i++) { + for (int i = 0; i < 20 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { blackhole.consume(localConnection.hasStatement(null, RDF.TYPE, null, true)); })); From 3486b22624375696b6349294db557f496b70d7d3 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Thu, 29 Aug 2024 13:08:30 -0400 Subject: [PATCH 08/25] JMH shell script --- run_jmh.sh | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100755 run_jmh.sh diff --git a/run_jmh.sh b/run_jmh.sh new file mode 100755 index 00000000000..1ac748d95ea --- /dev/null +++ b/run_jmh.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +mvn clean package -Pbenchmarks -DskipTests +java -jar ./core/sail/memory/target/jmh-benchmarks.jar ConcurrentQueryBenchmark +java -jar ./core/sail/memory/target/jmh-benchmarks.jar MemStatementListTestIT +java -jar ./compliance/repository/target/jmh-benchmarks.jar RepositoryFederatedServiceIntegrationTest +java -jar ./core/queryalgebra/evaluation/target/jmh-benchmarks.jar MinimalContextNowTest +java -jar ./core/sail/lucene/target/jmh-benchmarks.jar LuceneSailTest +java -jar ./core/sail/memory/target/jmh-benchmarks.jar ParallelQueryBenchmark +java -jar ./core/sail/memory/target/jmh-benchmarks.jar ParallelMixedReadWriteBenchmark +java -jar ./core/sail/memory/target/jmh-benchmarks.jar MemValueFactoryConcurrentBenchmark + +java -jar ./core/sail/lmdb/target/jmh-benchmarks.jar OverflowBenchmarkConcurrent +java -jar ./core/sail/nativerdf/target/jmh-benchmarks.jar OverflowBenchmarkConcurrent From 41fff93cbb07eeebd791c39f2a829be143155424 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Fri, 22 Nov 2024 10:27:37 -0500 Subject: [PATCH 09/25] Change workload (legacy) --- .../sail/memory/benchmark/ConcurrentQueryBenchmark.java | 8 ++++---- .../benchmark/MemValueFactoryConcurrentBenchmark.java | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java index 5f842f36aac..7c355dc6ae7 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java @@ -88,7 +88,7 @@ public void tearDown() throws Exception { public void hasStatement(Blackhole blackhole) throws Exception { threads(numThreads, () -> { try (SailRepositoryConnection connection = repository.getConnection()) { - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 50; i++) { boolean b = connection.hasStatement(null, null, null, true); blackhole.consume(b); } @@ -100,7 +100,7 @@ public void hasStatement(Blackhole blackhole) throws Exception { public void hasStatementSharedConnection(Blackhole blackhole) throws Exception { try (SailRepositoryConnection connection = repository.getConnection()) { threads(numThreads, () -> { - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 50; i++) { boolean b = connection.hasStatement(null, null, null, true); blackhole.consume(b); } @@ -112,7 +112,7 @@ public void hasStatementSharedConnection(Blackhole blackhole) throws Exception { public void getNamespaces(Blackhole blackhole) throws Exception { threads(numThreads, () -> { try (SailRepositoryConnection connection = repository.getConnection()) { - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 50; i++) { blackhole.consume(connection.getNamespaces().stream().count()); } } @@ -123,7 +123,7 @@ public void getNamespaces(Blackhole blackhole) throws Exception { public void getNamespacesSharedConnection(Blackhole blackhole) throws Exception { try (SailRepositoryConnection connection = repository.getConnection()) { threads(numThreads, () -> { - for (int i = 0; i < 100; i++) { + for (int i = 0; i < 50; i++) { blackhole.consume(connection.getNamespaces().stream().count()); } }); diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java index 58fd3b640c7..ca8b09e9417 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java @@ -66,7 +66,7 @@ public class MemValueFactoryConcurrentBenchmark extends BaseConcurrentBenchmark @Param({ "10", "50", "100", "500", "1000", "5000" }) public int numThreads; - public static final int BUCKET_SIZE = 10000; + public static final int BUCKET_SIZE = 5000; private SailRepository repository; private List> values; From 303b6c1cc5efdcd731586bf7999f47144c4af10c Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Fri, 22 Nov 2024 16:33:27 -0500 Subject: [PATCH 10/25] Increase heap space --- .../memory/benchmark/MemValueFactoryConcurrentBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java index 58fd3b640c7..7e75eb46017 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java @@ -58,7 +58,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", }) +@Fork(value = 1, jvmArgs = { "-Xms20G", "-Xmx20G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class MemValueFactoryConcurrentBenchmark extends BaseConcurrentBenchmark { From b2ab5209bffb6f3bc5ae562b5c52fab761434dc7 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 26 Nov 2024 15:28:33 -0500 Subject: [PATCH 11/25] Update MemStatementListTestIT.java --- .../eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java index 00b6701ca3b..b625561a81f 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java @@ -109,7 +109,7 @@ public static void beforeAll() throws IOException { statements = stream .map(s -> ((MemStatement) s)) .sorted(Comparator.comparing(Object::toString)) - .limit(10000) + .limit(5000) .collect(Collectors.toList()); } connection.commit(); From 032a9a50d2cc2d001b96ebcd1a0a86fb813eeb73 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 26 Nov 2024 20:24:53 -0500 Subject: [PATCH 12/25] Update ParallelMixedReadWriteBenchmark.java --- .../sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java index b7a2f0aedd5..94b069f5869 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java @@ -258,7 +258,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch for (int i = 0; i < 20 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { - for (int j = 0; j < 100; j++) { + for (int j = 0; j < 25; j++) { localConnection.add(Values.bnode(), RDFS.LABEL, Values.literal(j), Values.iri("http://example.com/g1")); } From 123ec2892e58d8dc7acb6b6ed1e53df555030b6f Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 26 Nov 2024 21:02:28 -0500 Subject: [PATCH 13/25] Update ParallelMixedReadWriteBenchmark.java --- .../sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java index 94b069f5869..a207d7a90d3 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java @@ -68,7 +68,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms64M", "-Xmx512M" }) +@Fork(value = 1) //@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:StartFlightRecording=delay=20s,duration=120s,filename=recording.jfr,settings=profile", "-XX:FlightRecorderOptions=samplethreads=true,stackdepth=1024", "-XX:+UnlockDiagnosticVMOptions", "-XX:+DebugNonSafepoints" }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) From ba77308651211ae17157de3e7e3dd805ec53cf26 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:48:26 -0500 Subject: [PATCH 14/25] Restore workload in ConcurrentQueryBenchmark.java --- .../sail/memory/benchmark/ConcurrentQueryBenchmark.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java index 7c355dc6ae7..5f842f36aac 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java @@ -88,7 +88,7 @@ public void tearDown() throws Exception { public void hasStatement(Blackhole blackhole) throws Exception { threads(numThreads, () -> { try (SailRepositoryConnection connection = repository.getConnection()) { - for (int i = 0; i < 50; i++) { + for (int i = 0; i < 100; i++) { boolean b = connection.hasStatement(null, null, null, true); blackhole.consume(b); } @@ -100,7 +100,7 @@ public void hasStatement(Blackhole blackhole) throws Exception { public void hasStatementSharedConnection(Blackhole blackhole) throws Exception { try (SailRepositoryConnection connection = repository.getConnection()) { threads(numThreads, () -> { - for (int i = 0; i < 50; i++) { + for (int i = 0; i < 100; i++) { boolean b = connection.hasStatement(null, null, null, true); blackhole.consume(b); } @@ -112,7 +112,7 @@ public void hasStatementSharedConnection(Blackhole blackhole) throws Exception { public void getNamespaces(Blackhole blackhole) throws Exception { threads(numThreads, () -> { try (SailRepositoryConnection connection = repository.getConnection()) { - for (int i = 0; i < 50; i++) { + for (int i = 0; i < 100; i++) { blackhole.consume(connection.getNamespaces().stream().count()); } } @@ -123,7 +123,7 @@ public void getNamespaces(Blackhole blackhole) throws Exception { public void getNamespacesSharedConnection(Blackhole blackhole) throws Exception { try (SailRepositoryConnection connection = repository.getConnection()) { threads(numThreads, () -> { - for (int i = 0; i < 50; i++) { + for (int i = 0; i < 100; i++) { blackhole.consume(connection.getNamespaces().stream().count()); } }); From 95402fd1796c27d053492092898e74dd873c7dfb Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:48:32 -0500 Subject: [PATCH 15/25] Restore workload in MemValueFactoryConcurrentBenchmark.java --- .../memory/benchmark/MemValueFactoryConcurrentBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java index a7b5a87a53f..7e75eb46017 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java @@ -66,7 +66,7 @@ public class MemValueFactoryConcurrentBenchmark extends BaseConcurrentBenchmark @Param({ "10", "50", "100", "500", "1000", "5000" }) public int numThreads; - public static final int BUCKET_SIZE = 5000; + public static final int BUCKET_SIZE = 10000; private SailRepository repository; private List> values; From d258de6aeb7c4e11848dcaea4111b3d5aa4a9e19 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:49:05 -0500 Subject: [PATCH 16/25] Restore workload in ParallelMixedReadWriteBenchmark.java --- .../sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java index a207d7a90d3..3982304f5d0 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java @@ -258,7 +258,7 @@ private ArrayList getMixedWorkload(Blackhole blackhole, CountDownLatch for (int i = 0; i < 20 * workloadSize; i++) { list.add(getRunnable(startSignal, connection, isolationLevel, (localConnection) -> { - for (int j = 0; j < 25; j++) { + for (int j = 0; j < 100; j++) { localConnection.add(Values.bnode(), RDFS.LABEL, Values.literal(j), Values.iri("http://example.com/g1")); } From 2f2e5e235a07a9dd15ed63b6351ab0a94c433ed6 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:49:14 -0500 Subject: [PATCH 17/25] Restore workload in MemStatementListTestIT.java --- .../eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java index b625561a81f..00b6701ca3b 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java @@ -109,7 +109,7 @@ public static void beforeAll() throws IOException { statements = stream .map(s -> ((MemStatement) s)) .sorted(Comparator.comparing(Object::toString)) - .limit(5000) + .limit(10000) .collect(Collectors.toList()); } connection.commit(); From c073cb8cb483ce73f34e8e70a3ff2aeb3b16e555 Mon Sep 17 00:00:00 2001 From: Raffi Khatchadourian Date: Wed, 11 Dec 2024 13:29:46 -0500 Subject: [PATCH 18/25] Add back space. --- .../query/algebra/evaluation/impl/MinimalContextNowTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java index a7bdbbe674d..8340a2f0204 100644 --- a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java +++ b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java @@ -27,6 +27,7 @@ import org.eclipse.rdf4j.query.impl.EmptyBindingSet; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; + import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; import org.openjdk.jmh.annotations.Fork; From 8941b011df44ab3b4385d56052904e46f85d9921 Mon Sep 17 00:00:00 2001 From: Raffi Khatchadourian Date: Wed, 11 Dec 2024 13:31:44 -0500 Subject: [PATCH 19/25] Add back space. --- .../java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java b/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java index 1e957192e9c..64d2452a767 100644 --- a/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java +++ b/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java @@ -25,6 +25,7 @@ import org.eclipse.rdf4j.sail.SailException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; + /** * Unit tests for {@link AbstractSail}. * From 5582715a009c83b62bbb4601511d30f2ad3860b6 Mon Sep 17 00:00:00 2001 From: Raffi Khatchadourian Date: Wed, 11 Dec 2024 17:30:32 -0500 Subject: [PATCH 20/25] Use a higher max heap size. --- .../rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java index 5f842f36aac..78c9dcbc740 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ConcurrentQueryBenchmark.java @@ -43,7 +43,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ConcurrentQueryBenchmark extends BaseConcurrentBenchmark { From 5a472d666fb452cc2dd6550aafa612374284a5f5 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:14:01 -0500 Subject: [PATCH 21/25] Increase max heap size --- .../rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java index e972eea0d11..7f9c4c5b5c0 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelQueryBenchmark.java @@ -53,8 +53,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G" }) -//@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:StartFlightRecording=delay=20s,duration=120s,filename=recording.jfr,settings=profile", "-XX:FlightRecorderOptions=samplethreads=true,stackdepth=1024", "-XX:+UnlockDiagnosticVMOptions", "-XX:+DebugNonSafepoints" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ParallelQueryBenchmark extends BaseConcurrentBenchmark { From 457994e4e8e4629b21bce8ef7c332bf3aaab5870 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:14:06 -0500 Subject: [PATCH 22/25] Increase max heap size --- .../sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java index 3982304f5d0..8588011ff52 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/ParallelMixedReadWriteBenchmark.java @@ -68,8 +68,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1) -//@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:StartFlightRecording=delay=20s,duration=120s,filename=recording.jfr,settings=profile", "-XX:FlightRecorderOptions=samplethreads=true,stackdepth=1024", "-XX:+UnlockDiagnosticVMOptions", "-XX:+DebugNonSafepoints" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class ParallelMixedReadWriteBenchmark extends BaseConcurrentBenchmark { From c3f26f160367bdeec9f45c9cf8a53b7eea1dc267 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:14:13 -0500 Subject: [PATCH 23/25] Increase max heap size --- .../memory/benchmark/MemValueFactoryConcurrentBenchmark.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java index 7e75eb46017..87c09670d95 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/benchmark/MemValueFactoryConcurrentBenchmark.java @@ -58,7 +58,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms20G", "-Xmx20G", }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class MemValueFactoryConcurrentBenchmark extends BaseConcurrentBenchmark { From 3443145a4e00bc20be5d0b3ce24ce2266fc60b96 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:14:18 -0500 Subject: [PATCH 24/25] Increase max heap size --- .../eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java index 00b6701ca3b..85825e1da03 100644 --- a/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java +++ b/core/sail/memory/src/test/java/org/eclipse/rdf4j/sail/memory/model/MemStatementListTestIT.java @@ -71,7 +71,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class MemStatementListTestIT { From 5db29ea880c0dc67b1969afd29ddd847e3ea333a Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Thu, 12 Dec 2024 09:19:44 -0500 Subject: [PATCH 25/25] Remove unnecessary flags --- .../federation/RepositoryFederatedServiceIntegrationTest.java | 2 +- .../query/algebra/evaluation/impl/MinimalContextNowTest.java | 2 +- .../java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java | 2 +- .../rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java b/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java index 79817aa99ab..44508c88e9c 100644 --- a/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java +++ b/compliance/repository/src/test/java/org/eclipse/rdf4j/repository/sparql/federation/RepositoryFederatedServiceIntegrationTest.java @@ -67,7 +67,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class RepositoryFederatedServiceIntegrationTest { diff --git a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java index 8340a2f0204..23cd17560c7 100644 --- a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java +++ b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/MinimalContextNowTest.java @@ -47,7 +47,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class MinimalContextNowTest { diff --git a/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java b/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java index 64d2452a767..67b53e5a5c5 100644 --- a/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java +++ b/core/sail/api/src/test/java/org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java @@ -51,7 +51,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class AbstractSailTest { diff --git a/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java b/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java index b3f574e0bfa..67bc5588940 100644 --- a/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java +++ b/core/sail/lucene/src/test/java/org/eclipse/rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java @@ -91,7 +91,7 @@ @State(Scope.Benchmark) @Warmup(iterations = 5) @BenchmarkMode({ Mode.AverageTime }) -@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx1G", "-XX:+UseG1GC" }) +@Fork(value = 1, jvmArgs = { "-Xms1G", "-Xmx50G", }) @Measurement(iterations = 5) @OutputTimeUnit(TimeUnit.MILLISECONDS) public abstract class AbstractGenericLuceneTest {