test/org/apache/el/parser/TestELParserPerformance.java - tomcat - Git at Google

 /*
  * 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 java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.concurrent.Callable;

 import jakarta.el.ELBaseTest;
 import jakarta.el.ELContext;
 import jakarta.el.ELManager;
 import jakarta.el.ExpressionFactory;
 import jakarta.el.ValueExpression;

 import org.junit.Assert;
 import org.junit.Ignore;
 import org.junit.Test;

 import org.apache.tomcat.util.collections.SynchronizedStack;

 /*
  * This is a relative performance test so it remains part of the standard test run.
  */
 public class TestELParserPerformance extends ELBaseTest {

     private static final long DEFAULT_TEST_ITERATIONS = 1000000;

     /*
      * 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;

         long reinitTotalTime = 0;
         long newTotalTime = 0;

         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();
             reinitTotalTime += (end - start);

             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();
             newTotalTime += (end - start);

             System.out.println(parseIterations + " iterations using    new ELParser(...) took " + (end - start) + "ns");
         }

         Assert.assertTrue("Using new ElParser() was faster then using ELParser.ReInit", reinitTotalTime < newTotalTime);
     }


     /*
      * Ignored by default since this is an absolute test primarily for
      * https://bz.apache.org/bugzilla/show_bug.cgi?id=69338
      */
     @Ignore
     @Test
     public void testAstAnd() {

         ELManager manager = new ELManager();
         ELContext context = manager.getELContext();
         ExpressionFactory factory = ELManager.getExpressionFactory();

         long durations[] = new long[9];
         for (int j = 0; j < 5; j++) {
             for (int operandCount = 2; operandCount < 11; operandCount++) {

                 StringBuilder sb = new StringBuilder("${true");
                 for (int i = 2; i <= operandCount; i++) {
                     sb.append(" && true");
                 }
                 sb.append("}");

                 String expression = sb.toString();

                 long start = System.nanoTime();

                 for (int i = 0; i < 2000000; i++) {
                     ValueExpression ve = factory.createValueExpression(context, expression, Boolean.class);
                     Boolean result = ve.getValue(context);
                     Assert.assertEquals(Boolean.TRUE, result);
                 }

                 long duration = System.nanoTime() - start;

                 if (j > 0) {
                     durations[operandCount - 2] += duration;
                 }
             }
         }
         for (int operandCount = 2; operandCount < 11; operandCount++) {
             System.out.println("Operand count [" + operandCount + "], duration [" + durations[operandCount - 2] + "]");
         }
         System.out.println("");
     }


     /*
      * Ignored by default since this is an absolute test primarily for
      * https://bz.apache.org/bugzilla/show_bug.cgi?id=69338
      */
     @Ignore
     @Test
     public void testAstNotEmpty() {

         ELManager manager = new ELManager();
         ELContext context = manager.getELContext();
         ExpressionFactory factory = ELManager.getExpressionFactory();

         for (int j = 0; j < 5; j++) {

             String expression = "${not empty 'abc'}";

             long start = System.nanoTime();

             for (int i = 0; i < 10000000; i++) {
                 ValueExpression ve = factory.createValueExpression(context, expression, Boolean.class);
                 Boolean result = ve.getValue(context);
                 Assert.assertEquals(Boolean.TRUE, result);
             }

             long duration = System.nanoTime() - start;
             System.out.println("duration [" + duration + "]");

         }
         System.out.println("");
     }


     /*
      * Utility method for running tasks provided by the test*() methods.
      *
      * @param c           Callable to be executed.
      * @param description Label to be displayed in the results.
      *
      * @return Arbitrary response data provided by the Callable.
      */
     private Object runTest(Callable<Object> c, String description) throws Exception {

         Object result = null;
         for (int j = 0; j < 5; j++) {

             System.gc();
             long start = System.currentTimeMillis();

             for (int i = 0; i < DEFAULT_TEST_ITERATIONS; i++) {
                 result = c.call();
             }

             long duration = System.currentTimeMillis() - start;
             System.out.println(description + " duration=[" + duration + "ms] or " +
                     (duration * 1000000 / DEFAULT_TEST_ITERATIONS + " ns each"));

         }
         System.out.println("Result: " + result);

         return result;
     }


     /*
      * Performance test of various expressions. This can be easily modified to explore the performance of other
      * expressions.
      *
      * The operations tested in this method allocate many objects. For most consistent results, use runtime arguments
      * such as these: -Xms3g -Xmx3g -XX:+UseParallelGC
      *
      * Ignored by default since this is an absolute test primarily for
      * https://bz.apache.org/bugzilla/show_bug.cgi?id=69381
      */
     @Ignore
     @Test
     public void testExpressions() throws Exception {

         ELManager manager = new ELManager();
         ELContext context = manager.getELContext();
         ExpressionFactory factory = ELManager.getExpressionFactory();
         TesterBeanD beanD = new TesterBeanD();
         TesterBeanE beanE = new TesterBeanE();
         beanD.setBean(beanE);
         beanD.setName("name");
         beanE.setName("name");
         beanD.setStringMap(new HashMap<>());
         beanD.setValList(new ArrayList<>(Arrays.asList("a", "b", "c")));

         ValueExpression var = factory.createValueExpression(beanD, TesterBeanD.class);
         context.getVariableMapper().setVariable("beanD", var);

         ValueExpression varB = factory.createValueExpression(beanE, TesterBeanE.class);
         context.getVariableMapper().setVariable("beanE", varB);

         var = factory.createValueExpression(TesterEnum.ONE, TesterEnum.class);
         context.getVariableMapper().setVariable("enumOne", var);

         String[] expressions = new String[] { "${beanD.name}", "${beanD.getName()}", "${beanE.getName()}" };
         for (String expression : expressions) {
             runTest(() -> {
                 ValueExpression ve = factory.createValueExpression(context, expression, Object.class);
                 return ve.getValue(context);
             }, expression);
         }
     }
 }
	/*
	* 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 java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.concurrent.Callable;

	import jakarta.el.ELBaseTest;
	import jakarta.el.ELContext;
	import jakarta.el.ELManager;
	import jakarta.el.ExpressionFactory;
	import jakarta.el.ValueExpression;

	import org.junit.Assert;
	import org.junit.Ignore;
	import org.junit.Test;

	import org.apache.tomcat.util.collections.SynchronizedStack;

	/*
	* This is a relative performance test so it remains part of the standard test run.
	*/
	public class TestELParserPerformance extends ELBaseTest {

	private static final long DEFAULT_TEST_ITERATIONS = 1000000;

	/*
	* 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;

	long reinitTotalTime = 0;
	long newTotalTime = 0;

	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();
	reinitTotalTime += (end - start);

	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();
	newTotalTime += (end - start);

	System.out.println(parseIterations + " iterations using new ELParser(...) took " + (end - start) + "ns");
	}

	Assert.assertTrue("Using new ElParser() was faster then using ELParser.ReInit", reinitTotalTime < newTotalTime);
	}


	/*
	* Ignored by default since this is an absolute test primarily for
	* https://bz.apache.org/bugzilla/show_bug.cgi?id=69338
	*/
	@Ignore
	@Test
	public void testAstAnd() {

	ELManager manager = new ELManager();
	ELContext context = manager.getELContext();
	ExpressionFactory factory = ELManager.getExpressionFactory();

	long durations[] = new long[9];
	for (int j = 0; j < 5; j++) {
	for (int operandCount = 2; operandCount < 11; operandCount++) {

	StringBuilder sb = new StringBuilder("${true");
	for (int i = 2; i <= operandCount; i++) {
	sb.append(" && true");
	}
	sb.append("}");

	String expression = sb.toString();

	long start = System.nanoTime();

	for (int i = 0; i < 2000000; i++) {
	ValueExpression ve = factory.createValueExpression(context, expression, Boolean.class);
	Boolean result = ve.getValue(context);
	Assert.assertEquals(Boolean.TRUE, result);
	}

	long duration = System.nanoTime() - start;

	if (j > 0) {
	durations[operandCount - 2] += duration;
	}
	}
	}
	for (int operandCount = 2; operandCount < 11; operandCount++) {
	System.out.println("Operand count [" + operandCount + "], duration [" + durations[operandCount - 2] + "]");
	}
	System.out.println("");
	}


	/*
	* Ignored by default since this is an absolute test primarily for
	* https://bz.apache.org/bugzilla/show_bug.cgi?id=69338
	*/
	@Ignore
	@Test
	public void testAstNotEmpty() {

	ELManager manager = new ELManager();
	ELContext context = manager.getELContext();
	ExpressionFactory factory = ELManager.getExpressionFactory();

	for (int j = 0; j < 5; j++) {

	String expression = "${not empty 'abc'}";

	long start = System.nanoTime();

	for (int i = 0; i < 10000000; i++) {
	ValueExpression ve = factory.createValueExpression(context, expression, Boolean.class);
	Boolean result = ve.getValue(context);
	Assert.assertEquals(Boolean.TRUE, result);
	}

	long duration = System.nanoTime() - start;
	System.out.println("duration [" + duration + "]");

	}
	System.out.println("");
	}


	/*
	* Utility method for running tasks provided by the test*() methods.
	*
	* @param c Callable to be executed.
	* @param description Label to be displayed in the results.
	*
	* @return Arbitrary response data provided by the Callable.
	*/
	private Object runTest(Callable<Object> c, String description) throws Exception {

	Object result = null;
	for (int j = 0; j < 5; j++) {

	System.gc();
	long start = System.currentTimeMillis();

	for (int i = 0; i < DEFAULT_TEST_ITERATIONS; i++) {
	result = c.call();
	}

	long duration = System.currentTimeMillis() - start;
	System.out.println(description + " duration=[" + duration + "ms] or " +
	(duration * 1000000 / DEFAULT_TEST_ITERATIONS + " ns each"));

	}
	System.out.println("Result: " + result);

	return result;
	}


	/*
	* Performance test of various expressions. This can be easily modified to explore the performance of other
	* expressions.
	*
	* The operations tested in this method allocate many objects. For most consistent results, use runtime arguments
	* such as these: -Xms3g -Xmx3g -XX:+UseParallelGC
	*
	* Ignored by default since this is an absolute test primarily for
	* https://bz.apache.org/bugzilla/show_bug.cgi?id=69381
	*/
	@Ignore
	@Test
	public void testExpressions() throws Exception {

	ELManager manager = new ELManager();
	ELContext context = manager.getELContext();
	ExpressionFactory factory = ELManager.getExpressionFactory();
	TesterBeanD beanD = new TesterBeanD();
	TesterBeanE beanE = new TesterBeanE();
	beanD.setBean(beanE);
	beanD.setName("name");
	beanE.setName("name");
	beanD.setStringMap(new HashMap<>());
	beanD.setValList(new ArrayList<>(Arrays.asList("a", "b", "c")));

	ValueExpression var = factory.createValueExpression(beanD, TesterBeanD.class);
	context.getVariableMapper().setVariable("beanD", var);

	ValueExpression varB = factory.createValueExpression(beanE, TesterBeanE.class);
	context.getVariableMapper().setVariable("beanE", varB);

	var = factory.createValueExpression(TesterEnum.ONE, TesterEnum.class);
	context.getVariableMapper().setVariable("enumOne", var);

	String[] expressions = new String[] { "${beanD.name}", "${beanD.getName()}", "${beanE.getName()}" };
	for (String expression : expressions) {
	runTest(() -> {
	ValueExpression ve = factory.createValueExpression(context, expression, Object.class);
	return ve.getValue(context);
	}, expression);
	}
	}
	}