From 365f747f59e10d2b39868fbadbf3f62f6c665336 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 19:23:31 -0400 Subject: [PATCH 01/21] Additional JMH tests (fibers) --- compliance/repository/pom.xml | 12 +++++++ ...sitoryFederatedServiceIntegrationTest.java | 31 +++++++++++++++- .../impl/MinimalContextNowTest.java | 28 ++++++++++++++- .../rdf4j/sail/helpers/AbstractSailTest.java | 29 ++++++++++++++- core/sail/lucene/pom.xml | 12 +++++++ .../impl/AbstractGenericLuceneTest.java | 32 ++++++++++++++++- .../memory/model/MemStatementListTestIT.java | 35 ++++++++++++++++++- 7 files changed, 174 insertions(+), 5 deletions(-) diff --git a/compliance/repository/pom.xml b/compliance/repository/pom.xml index b5e75f0c7b..95e48a074a 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 9b92fd657e..42c7ab1731 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.newVirtualThreadPerTaskExecutor(); 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 99102c89d6..0d8f0545ee 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; @@ -27,8 +28,33 @@ 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 +71,9 @@ public void testNow() { } @Test + @Benchmark public void testConcurrentAccessToNow() throws ExecutionException, InterruptedException { int numberOfIterations = 100; - int numberOfThreads = 10; ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor(); 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 0d3b6312d5..1f537de9f3 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 @@ -26,18 +26,45 @@ 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.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; + /** * Unit tests for {@link AbstractSail}. * * @author Jeen Broekstra */ +@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 +123,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 a0e0c7f070..c9252913b6 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 6aee01eb74..5c828106dd 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 @@ -70,8 +70,36 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +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; + @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 +148,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 +180,7 @@ public void setUp() throws Exception { } @AfterEach + @TearDown(Level.Iteration) public void tearDown() throws RepositoryException { try { if (connection != null) { @@ -767,8 +797,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 5938b52986..2f9601add0 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; @@ -50,14 +51,43 @@ import com.google.common.collect.Lists; +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; + @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 = 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()) { @@ -91,6 +121,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 +131,7 @@ public void beforeEach() { @Test @Timeout(120) + @Benchmark public void addMultipleThreads() throws ExecutionException, InterruptedException { List> partition = Lists.partition(statements, CHUNKS); @@ -140,6 +172,7 @@ public void addMultipleThreads() throws ExecutionException, InterruptedException @Test @Timeout(120) + @Benchmark public void addMultipleThreadsAndCleanupThread() throws ExecutionException, InterruptedException { List> partition = Lists.partition(statements, CHUNKS); From f987a6203633abf68686e0f71dac9da21c54d1f8 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 19:36:50 -0400 Subject: [PATCH 02/21] Sort imports --- .../query/algebra/evaluation/impl/MinimalContextNowTest.java | 1 - .../org/eclipse/rdf4j/sail/helpers/AbstractSailTest.java | 1 - .../rdf4j/sail/lucene/impl/AbstractGenericLuceneTest.java | 5 ++--- .../rdf4j/sail/memory/model/MemStatementListTestIT.java | 5 ++--- 4 files changed, 4 insertions(+), 8 deletions(-) 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 0d8f0545ee..4dd072a274 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,7 +27,6 @@ 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; 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 1f537de9f3..aafa9f2551 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,7 +25,6 @@ import org.eclipse.rdf4j.sail.SailException; 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; 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 5c828106dd..8acbd227cb 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,9 +67,6 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; import org.openjdk.jmh.annotations.Fork; @@ -87,6 +84,8 @@ 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) 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 2f9601add0..52f914c367 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 @@ -48,9 +48,6 @@ import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; - -import com.google.common.collect.Lists; - import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; import org.openjdk.jmh.annotations.Fork; @@ -68,6 +65,8 @@ 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) From 720851cd5e018b278f0ca693e9fe75a325d41f84 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 19:38:54 -0400 Subject: [PATCH 03/21] Format --- .../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 52f914c367..13fbb59e6c 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 @@ -77,7 +77,7 @@ public class MemStatementListTestIT { private static List statements; - + @Param({ "10", "50", "100", "500", "1000", "5000" }) public static int CHUNKS = 1_000; From f1e71cd15e466ebea470979dffdd92558618c0dc Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 23:16:40 -0400 Subject: [PATCH 04/21] 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 e9f5542be6..93383f868a 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 b4563e141a..3aa3e3c0c2 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 1785a1f735..5f842f36aa 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 4f5b02057c..9749514732 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 3e1bae0270..9b9a2fa7c1 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 d5dfcafd32..6fc0a600a1 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 558c257f1a..78c8502485 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 a058a00a4a578a9032b09d551d609a6fa4307f26 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 23:18:33 -0400 Subject: [PATCH 05/21] Format --- .../MemValueFactoryConcurrentBenchmark.java | 2 +- .../benchmark/ParallelMixedReadWriteBenchmark.java | 12 ++++++------ .../memory/benchmark/ParallelQueryBenchmark.java | 10 +++++----- 3 files changed, 12 insertions(+), 12 deletions(-) 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 9749514732..58fd3b640c 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 @@ -65,7 +65,7 @@ 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; 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 9b9a2fa7c1..b7a2f0aedd 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 6fc0a600a1..e972eea0d1 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 ab543889519f48e048d6f4d9768cb8c8cdba9855 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 23:21:17 -0400 Subject: [PATCH 06/21] Format --- .../sail/nativerdf/benchmark/OverflowBenchmarkConcurrent.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 78c8502485..cbcac5afc1 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 @@ -79,7 +79,7 @@ public class OverflowBenchmarkConcurrent { @Param({ "5", "25", "50", "250", "500", "2500" }) public int numThreadsHalf; - + @Setup(Level.Trial) public void setup() { ((Logger) (LoggerFactory From f9d8b497d54e7807475ddda536de782c8a890d2b Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Mon, 26 Aug 2024 23:47:05 -0400 Subject: [PATCH 07/21] Formatting --- .../rdf4j/sail/lmdb/benchmark/OverflowBenchmarkConcurrent.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 3aa3e3c0c2..dab49b24bb 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 @@ -81,7 +81,7 @@ public class OverflowBenchmarkConcurrent { @Param({ "5", "25", "50", "250", "500", "2500" }) public int numThreadsHalf; - + @Setup(Level.Trial) public void setup() { ((Logger) (LoggerFactory From b0022753ee608359af9bbc2c23e9f7a82d2afa34 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Thu, 29 Aug 2024 13:09:05 -0400 Subject: [PATCH 08/21] JMH shell script --- run_jmh.sh | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 run_jmh.sh diff --git a/run_jmh.sh b/run_jmh.sh new file mode 100644 index 0000000000..1ac748d95e --- /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 8c18f4d2ae0c94a8eed99865067170ce75b34e64 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Fri, 22 Nov 2024 10:29:00 -0500 Subject: [PATCH 09/21] Change workload (fibers) --- .../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 5f842f36aa..7c355dc6ae 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 58fd3b640c..ca8b09e941 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 527553283fdc28ce9e562c975ecc6edde03c645a Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Fri, 22 Nov 2024 16:34:37 -0500 Subject: [PATCH 10/21] 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 58fd3b640c..7e75eb4601 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 8d84b003db262e38ddf525050fb7597a5e3331a1 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 26 Nov 2024 15:28:21 -0500 Subject: [PATCH 11/21] 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 13fbb59e6c..6ed30f7eb3 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 aaae3aa04ea7ed5724c53acb5f54a59c0f835bc2 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 26 Nov 2024 20:24:56 -0500 Subject: [PATCH 12/21] 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 b7a2f0aedd..94b069f586 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 2975273203ec1e0da1506730d17bdb5b7c1300fa Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Tue, 26 Nov 2024 21:02:22 -0500 Subject: [PATCH 13/21] 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 94b069f586..a207d7a90d 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 f8d5940e09b634cdcd958d8d141b75afb556c7ee Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Tue, 3 Dec 2024 14:48:11 -0500 Subject: [PATCH 14/21] Restore workloads --- .../sail/memory/benchmark/ConcurrentQueryBenchmark.java | 8 ++++---- .../benchmark/MemValueFactoryConcurrentBenchmark.java | 2 +- .../memory/benchmark/ParallelMixedReadWriteBenchmark.java | 2 +- .../rdf4j/sail/memory/model/MemStatementListTestIT.java | 2 +- 4 files changed, 7 insertions(+), 7 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 7c355dc6ae..5f842f36aa 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()); } }); 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 a7b5a87a53..7e75eb4601 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; 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 a207d7a90d..3982304f5d 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")); } 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 6ed30f7eb3..13fbb59e6c 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 df68c3306561933137ea425906a9d376d9c94671 Mon Sep 17 00:00:00 2001 From: Raffi Khatchadourian Date: Wed, 11 Dec 2024 15:02:43 -0500 Subject: [PATCH 15/21] 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 4dd072a274..0d8f0545ee 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 d8524f380296125002c1e4e50f67d02e0042b521 Mon Sep 17 00:00:00 2001 From: Raffi Khatchadourian Date: Wed, 11 Dec 2024 17:30:32 -0500 Subject: [PATCH 16/21] 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 5f842f36aa..78c9dcbc74 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 108ae4d7a0d3507ebfcc95f4366a9c66b312d09d Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:16:18 -0500 Subject: [PATCH 17/21] Update ParallelQueryBenchmark.java --- .../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 e972eea0d1..7f9c4c5b5c 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 e5481e77e0063b580b67c3110cfd1d9c574e69f4 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:16:29 -0500 Subject: [PATCH 18/21] Update ParallelMixedReadWriteBenchmark.java --- .../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 3982304f5d..8588011ff5 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 baa9227893fcdc9b17d251ce450d7a9cb5a500d6 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:16:37 -0500 Subject: [PATCH 19/21] Update 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 7e75eb4601..87c09670d9 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 c9d67693fe13554273098e8666c229edced585a5 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme <139664105+bgprudhomme@users.noreply.github.com> Date: Wed, 11 Dec 2024 20:16:46 -0500 Subject: [PATCH 20/21] 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 13fbb59e6c..c5e76961b3 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 79cfa385f404e6fa8732540ac8c16d3f5e738201 Mon Sep 17 00:00:00 2001 From: Benjamin Prud'homme Date: Thu, 12 Dec 2024 09:20:37 -0500 Subject: [PATCH 21/21] 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 42c7ab1731..92b22b4073 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 0d8f0545ee..f55ce6a8c2 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 aafa9f2551..e53980e8ce 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 @@ -50,7 +50,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 8acbd227cb..0e88746a85 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 {