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