commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hen...@apache.org
Subject svn commit: r896643 - /commons/proper/jexl/trunk/src/test/java/org/apache/commons/jexl2/CacheTest.java
Date Wed, 06 Jan 2010 19:46:20 GMT
Author: henrib
Date: Wed Jan  6 19:46:18 2010
New Revision: 896643

URL: http://svn.apache.org/viewvc?rev=896643&view=rev
Log:
Refactored to to run multi-threaded; this verifies the expression cache and volatile AST node
cache usage do not induce errors.

Modified:
    commons/proper/jexl/trunk/src/test/java/org/apache/commons/jexl2/CacheTest.java

Modified: commons/proper/jexl/trunk/src/test/java/org/apache/commons/jexl2/CacheTest.java
URL: http://svn.apache.org/viewvc/commons/proper/jexl/trunk/src/test/java/org/apache/commons/jexl2/CacheTest.java?rev=896643&r1=896642&r2=896643&view=diff
==============================================================================
--- commons/proper/jexl/trunk/src/test/java/org/apache/commons/jexl2/CacheTest.java (original)
+++ commons/proper/jexl/trunk/src/test/java/org/apache/commons/jexl2/CacheTest.java Wed Jan
 6 19:46:18 2010
@@ -16,8 +16,13 @@
  */
 package org.apache.commons.jexl2;
 
-import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Verifies cache & tryExecute
@@ -33,7 +38,10 @@
         jexl.setLenient(false);
         jexl.setSilent(false);
     }
-    private static final int LOOPS = 1024;
+
+    // LOOPS & THREADS
+    private static final int LOOPS = 4096;
+    private static final int NTHREADS = 4;
     // A pseudo random mix of accessors
     private static final int[] MIX = {
         0, 0, 3, 3, 4, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 1, 1, 1, 2, 2, 2,
@@ -44,7 +52,12 @@
     protected void tearDown() throws Exception {
         debuggerCheck(jexl);
     }
-    
+
+    /**
+     * A set of classes that define different getter/setter methods for the same properties.
+     * The goal is to verify that the cached JexlPropertyGet / JexlPropertySet in the AST
Nodes are indeed
+     * volatile and do not generate errors even when multiple threads concurently hammer
them.
+     */
     public static class Cached {
         public String compute(String arg) {
             if (arg == null) {
@@ -237,6 +250,9 @@
         }
     }
 
+    /**
+     * A helper class to pass arguments in tests (instances of getter/setter exercising classes).
+     */
     static class TestCacheArguments {
         Cached0 c0 = new Cached0();
         Cached1 c1 = new Cached1();
@@ -246,10 +262,17 @@
         Object[] ca = {
             c0, c1, c2, c3, c4
         };
-        Object value = null;
+        Object[] value = null;
     }
 
-    void doAssign(TestCacheArguments x, int loops, boolean cache) throws Exception {
+    /**
+     * Run same test function in NTHREADS in parallel.
+     * @param ctask the task / test
+     * @param loops number of loops to perform
+     * @param cache whether jexl cache is used or not
+     * @throws Exception if anything goes wrong
+     */
+    void runThreaded(Class<? extends Task> ctask, int loops, boolean cache) throws
Exception {
         if (loops == 0) {
             loops = MIX.length;
         }
@@ -258,251 +281,322 @@
         } else {
             jexl.setCache(0);
         }
-        Map<String, Object> vars = new HashMap<String,Object>();
-        JexlContext jc = new MapContext(vars);
-        Expression cacheGetValue = jexl.createExpression("cache.value");
-        Expression cacheSetValue = jexl.createExpression("cache.value = value");
-        Object result;
+        java.util.concurrent.ExecutorService execs = java.util.concurrent.Executors.newFixedThreadPool(NTHREADS);
+        List<Task> tasks = new ArrayList<Task>(NTHREADS);
+        for(int t = 0; t < NTHREADS; ++t) {
+            tasks.add(jexl.newInstance(ctask, loops));
+        }
+        // let's not wait for more than a minute
+        List<Future<Integer>> futures = execs.invokeAll(tasks, 60, TimeUnit.SECONDS);
+        // check that all returned loops
+        for(Future<Integer> future : futures) {
+            assertEquals(Integer.valueOf(loops), future.get());
+        }
+    }
 
-        for (int l = 0; l < loops; ++l) {
-            int mix = MIX[l % MIX.length];
+    /**
+     * The base class for MT tests.
+     */
+    public abstract static class Task implements Callable<Integer> {
+        final TestCacheArguments args = new TestCacheArguments();
+        final int loops;
+        final Map<String, Object> vars = new HashMap<String, Object>();
+        final JexlContext jc = new MapContext(vars);
+
+        Task(int loops) {
+            this.loops = loops;
+        }
+
+        public abstract Integer call() throws Exception;
+
+        /**
+         * The actual test function; assigns and checks.
+         * <p>The expression will be evaluated against different classes in parallel.
+         * This verifies that neither the volatile cache in the AST nor the expression cache
in the JEXL engine
+         * induce errors.</p>
+         * <p>
+         * Using it as a micro benchmark, it shows creating expression as the dominating
cost; the expression
+         * cache takes care of this.
+         * By moving the expression creations out of the main loop, it also shows that the
volatile cache speeds
+         * things up around 2x.
+         * </p>
+         * @param value the argument value to control
+         * @return the number of loops performed
+         */
+        public Integer runAssign(Object value) {
+            args.value = new Object[]{value};
+            Object result;
+
+            Expression cacheGetValue = jexl.createExpression("cache.value");
+            Expression cacheSetValue = jexl.createExpression("cache.value = value");
+            for (int l = 0; l < loops; ++l) {
+                int px = (int) Thread.currentThread().getId();
+                int mix = MIX[(l + px) % MIX.length];
+
+                vars.put("cache", args.ca[mix]);
+                vars.put("value", args.value[0]);
+                result = cacheSetValue.evaluate(jc);
+                if (args.value[0] == null) {
+                    assertNull(cacheSetValue.toString(), result);
+                } else {
+                    assertEquals(cacheSetValue.toString(), args.value[0], result);
+                }
 
-            vars.put("cache", x.ca[mix]);
-            vars.put("value", x.value);
-            result = cacheSetValue.evaluate(jc);
-            if (x.value == null) {
-                assertNull(cacheSetValue.toString(), result);
-            } else {
-                assertEquals(cacheSetValue.toString(), x.value, result);
-            }
+                result = cacheGetValue.evaluate(jc);
+                if (args.value[0] == null) {
+                    assertEquals(cacheGetValue.toString(), "Cached" + mix + ":na", result);
+                } else {
+                    assertEquals(cacheGetValue.toString(), "Cached" + mix + ":" + args.value[0],
result);
+                }
 
-            result = cacheGetValue.evaluate(jc);
-            if (x.value == null) {
-                assertEquals(cacheGetValue.toString(), "Cached" + mix + ":na", result);
-            } else {
-                assertEquals(cacheGetValue.toString(), "Cached" + mix + ":" + x.value, result);
             }
 
+            return Integer.valueOf(loops);
         }
     }
 
-    public void testNullAssignNoCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        doAssign(args, LOOPS, false);
+    /**
+     * A task to check assignment.
+     */
+    public static class AssignTask extends Task {
+        public AssignTask(int loops) {
+            super(loops);
+        }
+        public Integer call() throws Exception {
+            return runAssign("foo");
+        }
     }
 
-    public void testNullAssignCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        doAssign(args, LOOPS, true);
+    /**
+     * A task to check null assignment.
+     */
+    public static class AssignNullTask extends Task {
+        public AssignNullTask(int loops) {
+            super(loops);
+        }
+        public Integer call() throws Exception {
+            return runAssign(null);
+        }
     }
 
-    public void testAssignNoCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.value = "foo";
-        doAssign(args, LOOPS, false);
-    }
+    /**
+     * A task to check boolean assignment.
+     */
+    public static class AssignBooleanTask extends Task {
+        public AssignBooleanTask(int loops) {
+            super(loops);
+        }
+        public Integer call() throws Exception {
+            return runAssignBoolean(Boolean.TRUE);
+        }
 
-    public void testAssignCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.value = "foo";
-        doAssign(args, LOOPS, true);
+        /** The actual test function. */
+        private Integer runAssignBoolean(Boolean value) {
+            args.value = new Object[]{value};
+            Expression cacheGetValue = jexl.createExpression("cache.flag");
+            Expression cacheSetValue = jexl.createExpression("cache.flag = value");
+            Object result;
+
+            for (int l = 0; l < loops; ++l) {
+                int px = (int) Thread.currentThread().getId();
+                int mix = MIX[(l + px) % MIX.length];
+
+                vars.put("cache", args.ca[mix]);
+                vars.put("value", args.value[0]);
+                result = cacheSetValue.evaluate(jc);
+                assertEquals(cacheSetValue.toString(), args.value[0], result);
+
+                result = cacheGetValue.evaluate(jc);
+                assertEquals(cacheGetValue.toString(), args.value[0], result);
+
+            }
+
+            return Integer.valueOf(loops);
+        }
     }
 
-    void doAssignBoolean(TestCacheArguments x, int loops, boolean cache) throws Exception
{
-        if (loops == 0) {
-            loops = MIX.length;
+    /**
+     * A task to check list assignment.
+     */
+    public static class AssignListTask extends Task {
+        public AssignListTask(int loops) {
+            super(loops);
         }
-        if (cache) {
-            jexl.setCache(32);
-        } else {
-            jexl.setCache(0);
+
+        public Integer call() throws Exception {
+            return runAssignList();
         }
-        Map<String, Object> vars = new HashMap<String,Object>();
-        JexlContext jc = new MapContext(vars);
-        Expression cacheGetValue = jexl.createExpression("cache.flag");
-        Expression cacheSetValue = jexl.createExpression("cache.flag = value");
-        Object result;
+        /** The actual test function. */
+        private Integer runAssignList() {
+            args.value = new Object[]{"foo"};
+            java.util.ArrayList<String> c1 = new java.util.ArrayList<String>(2);
+            c1.add("foo");
+            c1.add("bar");
+            args.ca = new Object[]{
+                        new String[]{"one", "two"},
+                        c1
+                    };
 
-        for (int l = 0; l < loops; ++l) {
-            int mix = MIX[l % MIX.length];
+            Expression cacheGetValue = jexl.createExpression("cache.0");
+            Expression cacheSetValue = jexl.createExpression("cache[0] = value");
+            Object result;
 
-            vars.put("cache", x.ca[mix]);
-            vars.put("value", x.value);
-            result = cacheSetValue.evaluate(jc);
-            assertEquals(cacheSetValue.toString(), x.value, result);
+            for (int l = 0; l < loops; ++l) {
+                int px = (int) Thread.currentThread().getId();
+                int mix = MIX[(l + px) % MIX.length] % args.ca.length;
 
-            result = cacheGetValue.evaluate(jc);
-            assertEquals(cacheGetValue.toString(), x.value, result);
+                vars.put("cache", args.ca[mix]);
+                vars.put("value", args.value[0]);
+                result = cacheSetValue.evaluate(jc);
+                assertEquals(cacheSetValue.toString(), args.value[0], result);
+
+                result = cacheGetValue.evaluate(jc);
+                assertEquals(cacheGetValue.toString(), args.value[0], result);
+            }
 
+            return Integer.valueOf(loops);
         }
     }
 
-    public void testAssignBooleanNoCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.value = Boolean.TRUE;
-        doAssignBoolean(args, LOOPS, false);
-    }
 
-    public void testAssignBooleanCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.value = Boolean.TRUE;
-        doAssignBoolean(args, LOOPS, true);
+    public void testNullAssignNoCache() throws Exception {
+        runThreaded(AssignNullTask.class, LOOPS, false);
     }
 
-    void doAssignList(TestCacheArguments x, int loops, boolean cache) throws Exception {
-        if (loops == 0) {
-            loops = MIX.length;
-        }
-        if (cache) {
-            jexl.setCache(32);
-        } else {
-            jexl.setCache(0);
-        }
-        Map<String, Object> vars = new HashMap<String,Object>();
-        JexlContext jc = new MapContext(vars);
-        Expression cacheGetValue = jexl.createExpression("cache.0");
-        Expression cacheSetValue = jexl.createExpression("cache[0] = value");
-        Object result;
+    public void testNullAssignCache() throws Exception {
+        runThreaded(AssignNullTask.class, LOOPS, true);
+    }
 
-        for (int l = 0; l < loops; ++l) {
-            int mix = MIX[l % MIX.length] % x.ca.length;
+    public void testAssignNoCache() throws Exception {
+        runThreaded(AssignTask.class, LOOPS, false);
+    }
 
-            vars.put("cache", x.ca[mix]);
-            vars.put("value", x.value);
-            result = cacheSetValue.evaluate(jc);
-            assertEquals(cacheSetValue.toString(), x.value, result);
+    public void testAssignCache() throws Exception {
+        runThreaded(AssignTask.class, LOOPS, true);
+    }
 
-            result = cacheGetValue.evaluate(jc);
-            assertEquals(cacheGetValue.toString(), x.value, result);
+    public void testAssignBooleanNoCache() throws Exception {
+        runThreaded(AssignBooleanTask.class, LOOPS, false);
+    }
 
-        }
+    public void testAssignBooleanCache() throws Exception {
+        runThreaded(AssignBooleanTask.class, LOOPS, true);
     }
 
     public void testAssignListNoCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.value = "foo";
-        java.util.ArrayList<String> c1 = new java.util.ArrayList<String>(2);
-        c1.add("foo");
-        c1.add("bar");
-        args.ca = new Object[]{
-            new String[]{"one", "two"},
-            c1
-        };
-        doAssignList(args, LOOPS, false);
+        runThreaded(AssignListTask.class, LOOPS, false);
     }
 
     public void testAssignListCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.value = "foo";
-        java.util.ArrayList<String> c1 = new java.util.ArrayList<String>(2);
-        c1.add("foo");
-        c1.add("bar");
-        args.ca = new Object[]{
-            new String[]{"one", "two"},
-            c1
-        };
-        doAssignList(args, LOOPS, true);
+        runThreaded(AssignListTask.class, LOOPS, true);
     }
 
-    void doCompute(TestCacheArguments x, int loops, boolean cache) throws Exception {
-        if (loops == 0) {
-            loops = MIX.length;
-        }
-        if (cache) {
-            jexl.setCache(32);
-        } else {
-            jexl.setCache(0);
-        }
-        Map<String, Object> vars = new HashMap<String,Object>();
-        JexlContext jc = new MapContext(vars);
-        jexl.setDebug(true);
-        Expression compute2 = jexl.createExpression("cache.compute(a0, a1)");
-        Expression compute1 = jexl.createExpression("cache.compute(a0)");
-        Expression compute1null = jexl.createExpression("cache.compute(a0)");
-        Expression ambiguous = jexl.createExpression("cache.ambiguous(a0, a1)");
-        jexl.setDebug(false);
-        Object result = null;
-        String expected = null;
-        for (int l = 0; l < loops; ++l) {
-            int mix = MIX[l % MIX.length] % x.ca.length;
+    /**
+     * A task to check method calls.
+     */
+    public static class ComputeTask extends Task {
+        public ComputeTask(int loops) {
+            super(loops);
+        }
+
+        public Integer call() throws Exception {
+            args.ca = new Object[]{args.c0, args.c1, args.c2};
+            args.value = new Object[]{new Integer(2), "quux"};
+            //jexl.setDebug(true);
+            Expression compute2 = jexl.createExpression("cache.compute(a0, a1)");
+            Expression compute1 = jexl.createExpression("cache.compute(a0)");
+            Expression compute1null = jexl.createExpression("cache.compute(a0)");
+            Expression ambiguous = jexl.createExpression("cache.ambiguous(a0, a1)");
+            //jexl.setDebug(false);
+
+            Object result = null;
+            String expected = null;
+            for (int l = 0; l < loops; ++l) {
+                int mix = MIX[l % MIX.length] % args.ca.length;
+                Object value = args.value[l % args.value.length];
+
+                vars.put("cache", args.ca[mix]);
+                if (value instanceof String) {
+                    vars.put("a0", "S0");
+                    vars.put("a1", "S1");
+                    expected = "Cached" + mix + "@s#S0,s#S1";
+                } else if (value instanceof Integer) {
+                    vars.put("a0", Integer.valueOf(7));
+                    vars.put("a1", Integer.valueOf(9));
+                    expected = "Cached" + mix + "@i#7,i#9";
+                } else {
+                    fail("unexpected value type");
+                }
+                result = compute2.evaluate(jc);
+                assertEquals(compute2.toString(), expected, result);
 
-            vars.put("cache", x.ca[mix]);
-            if (x.value instanceof String) {
-                vars.put("a0", "S0");
-                vars.put("a1", "S1");
-                expected = "Cached" + mix + "@s#S0,s#S1";
-            } else if (x.value instanceof Integer) {
-                vars.put("a0", Integer.valueOf(7));
-                vars.put("a1", Integer.valueOf(9));
-                expected = "Cached" + mix + "@i#7,i#9";
-            } else {
-                fail("unexpected value type");
-            }
-            result = compute2.evaluate(jc);
-            assertEquals(compute2.toString(), expected, result);
+                if (value instanceof Integer) {
+                    try {
+                        vars.put("a0", Short.valueOf((short) 17));
+                        vars.put("a1", Short.valueOf((short) 19));
+                        result = ambiguous.evaluate(jc);
+                        fail("should have thrown an exception");
+                    } catch (JexlException xany) {
+                        // throws due to ambiguous exception
+                    }
+                }
+
+                if (value instanceof String) {
+                    vars.put("a0", "X0");
+                    expected = "Cached" + mix + "@s#X0";
+                } else if (value instanceof Integer) {
+                    vars.put("a0", Integer.valueOf(5));
+                    expected = "Cached" + mix + "@i#5";
+                } else {
+                    fail("unexpected value type");
+                }
+                result = compute1.evaluate(jc);
+                assertEquals(compute1.toString(), expected, result);
 
-            if (x.value instanceof Integer) {
                 try {
-                    vars.put("a0", Short.valueOf((short) 17));
-                    vars.put("a1", Short.valueOf((short) 19));
-                    result = ambiguous.evaluate(jc);
+                    vars.put("a0", null);
+                    result = compute1null.evaluate(jc);
                     fail("should have thrown an exception");
                 } catch (JexlException xany) {
                     // throws due to ambiguous exception
+                    String sany = xany.getMessage();
+                    String tname = getClass().getName();
+                    if (!sany.startsWith(tname)) {
+                        fail("debug mode should carry caller information, "
+                                + sany + ", "
+                                + tname);
+                    }
                 }
             }
-
-            if (x.value instanceof String) {
-                vars.put("a0", "X0");
-                expected = "Cached" + mix + "@s#X0";
-            } else if (x.value instanceof Integer) {
-                vars.put("a0", Integer.valueOf(5));
-                expected = "Cached" + mix + "@i#5";
-            } else {
-                fail("unexpected value type");
-            }
-            result = compute1.evaluate(jc);
-            assertEquals(compute1.toString(), expected, result);
-
-            try {
-                vars.put("a0", null);
-                jexl.setDebug(true);
-                result = compute1null.evaluate(jc);
-                fail("should have thrown an exception");
-            } catch (JexlException xany) {
-                // throws due to ambiguous exception
-                String sany = xany.getMessage();
-                String tname = getClass().getName();
-                if (!sany.startsWith(tname)) {
-                    fail("debug mode should carry caller information, "
-                         + sany +", "
-                         + tname);
-                }
-            }
-            finally {
-                jexl.setDebug(false);
-            }
+            return Integer.valueOf(loops);
         }
     }
 
     public void testComputeNoCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.ca = new Object[]{
-                    args.c0, args.c1, args.c2
-                };
-        args.value = new Integer(2);
-        doCompute(args, LOOPS, false);
+        try {
+            jexl.setDebug(true);
+            runThreaded(ComputeTask.class, LOOPS, false);
+        } finally {
+            jexl.setDebug(false);
+        }
     }
 
     public void testComputeCache() throws Exception {
-        TestCacheArguments args = new TestCacheArguments();
-        args.ca = new Object[]{
-                    args.c0, args.c1, args.c2
-                };
-        args.value = new Integer(2);
-        doCompute(args, LOOPS, true);
+        try {
+            jexl.setDebug(true);
+            runThreaded(ComputeTask.class, LOOPS, true);
+        } finally {
+            jexl.setDebug(false);
+        }
     }
 
+    /**
+     * The remaining tests exercise the namespaced functions; not MT.
+     * @param x
+     * @param loops
+     * @param cache
+     * @throws Exception
+     */
     void doCOMPUTE(TestCacheArguments x, int loops, boolean cache) throws Exception {
         if (loops == 0) {
             loops = MIX.length;
@@ -512,7 +606,7 @@
         } else {
             jexl.setCache(0);
         }
-        Map<String, Object> vars = new HashMap<String,Object>();
+        Map<String, Object> vars = new HashMap<String, Object>();
         JexlContext jc = new MapContext(vars);
         java.util.Map<String, Object> funcs = new java.util.HashMap<String, Object>();
         jexl.setFunctions(funcs);
@@ -522,13 +616,14 @@
         String expected = null;
         for (int l = 0; l < loops; ++l) {
             int mix = MIX[l % MIX.length] % x.ca.length;
+            Object value = x.value[l % x.value.length];
 
             funcs.put("cached", x.ca[mix]);
-            if (x.value instanceof String) {
+            if (value instanceof String) {
                 vars.put("a0", "S0");
                 vars.put("a1", "S1");
                 expected = "CACHED@s#S0,s#S1";
-            } else if (x.value instanceof Integer) {
+            } else if (value instanceof Integer) {
                 vars.put("a0", Integer.valueOf(7));
                 vars.put("a1", Integer.valueOf(9));
                 expected = "CACHED@i#7,i#9";
@@ -538,10 +633,10 @@
             result = compute2.evaluate(jc);
             assertEquals(compute2.toString(), expected, result);
 
-            if (x.value instanceof String) {
+            if (value instanceof String) {
                 vars.put("a0", "X0");
                 expected = "CACHED@s#X0";
-            } else if (x.value instanceof Integer) {
+            } else if (value instanceof Integer) {
                 vars.put("a0", Integer.valueOf(5));
                 expected = "CACHED@i#5";
             } else {
@@ -555,19 +650,18 @@
     public void testCOMPUTENoCache() throws Exception {
         TestCacheArguments args = new TestCacheArguments();
         args.ca = new Object[]{
-            Cached.class, Cached1.class, Cached2.class
-        };
-        args.value = new Integer(2);
+                    Cached.class, Cached1.class, Cached2.class
+                };
+        args.value = new Object[]{new Integer(2), "quux"};
         doCOMPUTE(args, LOOPS, false);
     }
-    
+
     public void testCOMPUTECache() throws Exception {
         TestCacheArguments args = new TestCacheArguments();
         args.ca = new Object[]{
-            Cached.class, Cached1.class, Cached2.class
-        };
-        args.value = new Integer(2);
+                    Cached.class, Cached1.class, Cached2.class
+                };
+        args.value = new Object[]{new Integer(2), "quux"};
         doCOMPUTE(args, LOOPS, true);
     }
-
 }



Mime
View raw message