1 files changed, 258 insertions, 0 deletions
diff --git a/java/systests/src/old_test/java/org/apache/qpid/server/queue/QueuePerfTest.java b/java/systests/src/old_test/java/org/apache/qpid/server/queue/QueuePerfTest.java
new file mode 100644
index 0000000000..5b3857396d
--- /dev/null
+++ b/java/systests/src/old_test/java/org/apache/qpid/server/queue/QueuePerfTest.java
@@ -0,0 +1,258 @@
+/*
+ *
+ * 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.qpid.server.queue;
+
+import org.apache.qpid.server.util.AveragedRun;
+import org.apache.qpid.server.util.TimedRun;
+import org.apache.qpid.server.util.RunStats;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class QueuePerfTest extends TimedRun
+{
+    private final Factory _factory;
+    private final int _queueCount;
+    private final int _messages;
+    private final String _msg = "";
+    private List<Queue<String>> _queues;
+
+    QueuePerfTest(Factory factory, int queueCount, int messages)
+    {
+        super(factory + ", " + queueCount + ", " + messages);
+        _factory = factory;
+        _queueCount = queueCount;
+        _messages = messages;
+    }
+
+    protected void setup() throws Exception
+    {
+        //init
+        int count = Integer.getInteger("prepopulate", 0);
+//        System.err.println("Prepopulating with " + count + " items");
+        _queues = new ArrayList<Queue<String>>(_queueCount);
+        for (int i = 0; i < _queueCount; i++)
+        {
+            Queue<String> q = _factory.create();
+            for(int j = 0; j < count; ++j)
+            {
+                q.add("Item"+ j);
+            }
+            _queues.add(q);
+        }
+        System.gc();
+    }
+
+    protected void teardown() throws Exception
+    {
+        System.gc();
+    }
+
+    protected void run() throws Exception
+    {
+        //dispatch
+        for (int i = 0; i < _messages; i++)
+        {
+            for (Queue<String> q : _queues)
+            {
+                q.offer(_msg);
+                q.poll();
+            }
+        }
+    }
+
+    static interface Factory
+    {
+        Queue<String> create();
+    }
+
+    static Factory CONCURRENT = new Factory()
+    {
+        public Queue<String> create()
+        {
+            return new ConcurrentLinkedQueue<String>();
+        }
+
+        public String toString()
+        {
+            return "ConcurrentLinkedQueue";
+        }
+
+    };
+
+    static Factory SYNCHRONIZED = new Factory()
+    {
+        public Queue<String> create()
+        {
+            return new SynchronizedQueue<String>(new LinkedList<String>());
+        }
+
+
+        public String toString()
+        {
+            return "Synchronized LinkedList";
+        }
+    };
+
+    static Factory PLAIN = new Factory()
+    {
+        public Queue<String> create()
+        {
+            return new LinkedList<String>();
+        }
+
+        public String toString()
+        {
+            return "Plain LinkedList";
+        }
+    };
+
+    static class SynchronizedQueue<E> implements Queue<E>
+    {
+        private final Queue<E> queue;
+
+        SynchronizedQueue(Queue<E> queue)
+        {
+            this.queue = queue;
+        }
+
+        public synchronized E element()
+        {
+            return queue.element();
+        }
+
+        public synchronized boolean offer(E o)
+        {
+            return queue.offer(o);
+        }
+
+        public synchronized E peek()
+        {
+            return queue.peek();
+        }
+
+        public synchronized E poll()
+        {
+            return queue.poll();
+        }
+
+        public synchronized E remove()
+        {
+            return queue.remove();
+        }
+
+        public synchronized int size()
+        {
+            return queue.size();
+        }
+
+        public synchronized boolean isEmpty()
+        {
+            return queue.isEmpty();
+        }
+
+        public synchronized boolean contains(Object o)
+        {
+            return queue.contains(o);
+        }
+
+        public synchronized Iterator<E> iterator()
+        {
+            return queue.iterator();
+        }
+
+        public synchronized Object[] toArray()
+        {
+            return queue.toArray();
+        }
+
+        public synchronized <T>T[] toArray(T[] a)
+        {
+            return queue.toArray(a);
+        }
+
+        public synchronized boolean add(E o)
+        {
+            return queue.add(o);
+        }
+
+        public synchronized boolean remove(Object o)
+        {
+            return queue.remove(o);
+        }
+
+        public synchronized boolean containsAll(Collection<?> c)
+        {
+            return queue.containsAll(c);
+        }
+
+        public synchronized boolean addAll(Collection<? extends E> c)
+        {
+            return queue.addAll(c);
+        }
+
+        public synchronized boolean removeAll(Collection<?> c)
+        {
+            return queue.removeAll(c);
+        }
+
+        public synchronized boolean retainAll(Collection<?> c)
+        {
+            return queue.retainAll(c);
+        }
+
+        public synchronized void clear()
+        {
+            queue.clear();
+        }
+    }
+
+    static void run(String label, AveragedRun test) throws Exception
+    {
+        RunStats stats = test.call();
+        System.out.println((label == null ? "" : label + ", ") + test
+                + ", " + stats.getAverage() + ", " + stats.getMax() + ", " + stats.getMin());
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        Factory[] factories = new Factory[]{PLAIN, SYNCHRONIZED, CONCURRENT};
+        int iterations = 5;
+        String label = argv.length > 0 ? argv[0]: null;
+        System.out.println((label == null ? "" : "Label, ") + "Queue Type, No. of Queues, No. of Operations, Avg Time, Min Time, Max Time");
+        //vary number of queues:
+
+        for(Factory f : factories)
+        {
+            run(label, new AveragedRun(new QueuePerfTest(f, 100, 10000), iterations));
+            run(label, new AveragedRun(new QueuePerfTest(f, 1000, 10000), iterations));
+            run(label, new AveragedRun(new QueuePerfTest(f, 10000, 10000), iterations));
+            run(label, new AveragedRun(new QueuePerfTest(f, 1000, 1000), iterations));
+            run(label, new AveragedRun(new QueuePerfTest(f, 1000, 100000), iterations));
+        }
+    }
+
+}