You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by ma...@apache.org on 2024/01/03 20:03:10 UTC
(tomcat) 04/18: Refactor performance tests to separate class
This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 9.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit fef9076584170d33b64b4357cc43b4be487923d5
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Wed Jan 3 09:25:35 2024 +0000
Refactor performance tests to separate class
Removes 2 more skipped tests from a default test run
---
test/org/apache/el/parser/TestELParser.java | 61 ----------------
.../apache/el/parser/TestELParserPerformance.java | 82 ++++++++++++++++++++++
2 files changed, 82 insertions(+), 61 deletions(-)
diff --git a/test/org/apache/el/parser/TestELParser.java b/test/org/apache/el/parser/TestELParser.java
index ab1d1bbaf0..5d9e00c704 100644
--- a/test/org/apache/el/parser/TestELParser.java
+++ b/test/org/apache/el/parser/TestELParser.java
@@ -16,19 +16,15 @@
*/
package org.apache.el.parser;
-import java.io.StringReader;
-
import javax.el.ELContext;
import javax.el.ELException;
import javax.el.ExpressionFactory;
import javax.el.ValueExpression;
import org.junit.Assert;
-import org.junit.Ignore;
import org.junit.Test;
import org.apache.jasper.el.ELContextImpl;
-import org.apache.tomcat.util.collections.SynchronizedStack;
public class TestELParser {
@@ -230,61 +226,4 @@ public class TestELParser {
String result = (String) ve.getValue(context);
Assert.assertEquals(expected, result);
}
-
- /*
- * Test to explore if re-using Parser instances is faster.
- *
- * Tests on my laptop show:
- * - overhead by introducing the stack is in the noise for parsing even the
- * simplest expression
- * - efficiency from re-using the ELParser is measurable for even a single
- * reuse of the parser
- * - with large numbers of parses (~10k) performance for a trivial parse is
- * three times faster
- * - around the 100 iterations mark GC overhead adds significant noise to
- * the results - for consistent results you either need fewer parses to
- * avoid triggering GC or more parses so the GC effects are evenly
- * distributed between the runs
- *
- * Note that the test is single threaded.
- */
- @Ignore
- @Test
- public void testParserPerformance() throws ParseException {
- final int runs = 20;
- final int parseIterations = 10000;
-
-
- for (int j = 0; j < runs; j ++) {
- long start = System.nanoTime();
- SynchronizedStack<ELParser> stack = new SynchronizedStack<>();
-
- for (int i = 0; i < parseIterations; i ++) {
- ELParser parser = stack.pop();
- if (parser == null) {
- parser = new ELParser(new StringReader("${'foo'}"));
- } else {
- parser.ReInit(new StringReader("${'foo'}"));
- }
- parser.CompositeExpression();
- stack.push(parser);
- }
- long end = System.nanoTime();
-
- System.out.println(parseIterations +
- " iterations using ELParser.ReInit(...) took " + (end - start) + "ns");
- }
-
- for (int j = 0; j < runs; j ++) {
- long start = System.nanoTime();
- for (int i = 0; i < parseIterations; i ++) {
- ELParser parser = new ELParser(new StringReader("${'foo'}"));
- parser.CompositeExpression();
- }
- long end = System.nanoTime();
-
- System.out.println(parseIterations +
- " iterations using new ELParser(...) took " + (end - start) + "ns");
- }
- }
}
diff --git a/test/org/apache/el/parser/TestELParserPerformance.java b/test/org/apache/el/parser/TestELParserPerformance.java
new file mode 100644
index 0000000000..f4d90e7f9e
--- /dev/null
+++ b/test/org/apache/el/parser/TestELParserPerformance.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.el.parser;
+
+import java.io.StringReader;
+
+import org.junit.Test;
+
+import org.apache.tomcat.util.collections.SynchronizedStack;
+
+public class TestELParserPerformance {
+
+ /*
+ * Test to explore if re-using Parser instances is faster.
+ *
+ * Tests on my laptop show:
+ * - overhead by introducing the stack is in the noise for parsing even the
+ * simplest expression
+ * - efficiency from re-using the ELParser is measurable for even a single
+ * reuse of the parser
+ * - with large numbers of parses (~10k) performance for a trivial parse is
+ * three times faster
+ * - around the 100 iterations mark GC overhead adds significant noise to
+ * the results - for consistent results you either need fewer parses to
+ * avoid triggering GC or more parses so the GC effects are evenly
+ * distributed between the runs
+ *
+ * Note that the test is single threaded.
+ */
+ @Test
+ public void testParserInstanceReuse() throws ParseException {
+ final int runs = 20;
+ final int parseIterations = 10000;
+
+
+ for (int j = 0; j < runs; j ++) {
+ long start = System.nanoTime();
+ SynchronizedStack<ELParser> stack = new SynchronizedStack<>();
+
+ for (int i = 0; i < parseIterations; i ++) {
+ ELParser parser = stack.pop();
+ if (parser == null) {
+ parser = new ELParser(new StringReader("${'foo'}"));
+ } else {
+ parser.ReInit(new StringReader("${'foo'}"));
+ }
+ parser.CompositeExpression();
+ stack.push(parser);
+ }
+ long end = System.nanoTime();
+
+ System.out.println(parseIterations +
+ " iterations using ELParser.ReInit(...) took " + (end - start) + "ns");
+ }
+
+ for (int j = 0; j < runs; j ++) {
+ long start = System.nanoTime();
+ for (int i = 0; i < parseIterations; i ++) {
+ ELParser parser = new ELParser(new StringReader("${'foo'}"));
+ parser.CompositeExpression();
+ }
+ long end = System.nanoTime();
+
+ System.out.println(parseIterations +
+ " iterations using new ELParser(...) took " + (end - start) + "ns");
+ }
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org