/*
* Copyright 2008 Google Inc.
*
* Licensed 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 com.google.gwt.examples.benchmarks;
import com.google.gwt.benchmarks.client.Benchmark;
import com.google.gwt.benchmarks.client.IntRange;
import com.google.gwt.benchmarks.client.Operator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
/**
* Benchmarks common operations on both ArrayLists and Vectors. This test covers
* appends, inserts, and removes for various sizes and positions on both
* ArrayLists and Vectors.
*
*/
public class ArrayListAndVectorBenchmark extends Benchmark {
/**
* Many profiled widgets have position dependent insert/remove code.
* <code>Position</code> is a helper class meant to capture the positional
* information for these sorts of operations.
*/
protected static class Position {
public static final Position BEGIN = new Position("at the beginning");
public static final Position END = new Position("at the end");
public static final Position NONE = new Position("no location specified");
public static final Position VARIED = new Position("in varied locations");
public static final Iterable positions = new Iterable() {
public Iterator iterator() {
return Arrays.asList(new Position[] {BEGIN, END, NONE, VARIED}).iterator();
}
};
public static final Iterable positions2 = new Iterable() {
public Iterator iterator() {
return Arrays.asList(new Position[] {BEGIN, END, VARIED}).iterator();
}
};
private String label;
/**
* Constructor for <code>Position</code>.
*/
public Position(String label) {
this.label = label;
}
@Override
public String toString() {
return " " + label;
}
}
private static final int PRIME = 3001;
final IntRange insertRemoveRange = new IntRange(64, Integer.MAX_VALUE,
Operator.MULTIPLY, 2);
final IntRange baseRange = new IntRange(512, Integer.MAX_VALUE,
Operator.MULTIPLY, 2);
ArrayList list;
Vector vector;
int index = 0;
@Override
public String getModuleName() {
return "com.google.gwt.examples.Benchmarks";
}
/**
* Appends <code>size</code> items to an empty ArrayList.
*
* @gwt.benchmark.param size -limit = baseRange
*/
public void testArrayListAdds(Integer size) {
int num = size.intValue();
for (int i = 0; i < num; i++) {
list.add("hello");
}
}
// Required for JUnit
public void testArrayListAdds() {
}
/**
* Performs <code>size</code> gets on an ArrayList of size,
* <code>size</code>.
*
* @gwt.benchmark.param size -limit = baseRange
*/
public void testArrayListGets(Integer size) {
int num = size.intValue();
for (int i = 0; i < num; i++) {
list.get(i);
}
}
// Required for JUnit
public void testArrayListGets() {
}
/**
* Performs <code>size</code> inserts at position, <code>where</code>, on
* an empty ArrayList.
*
* @gwt.benchmark.param where = Position.positions
* @gwt.benchmark.param size -limit = insertRemoveRange
*/
public void testArrayListInserts(Position where, Integer size) {
insertIntoCollection(size, where, list);
}
// Required for JUnit
public void testArrayListInserts() {
}
/**
* Performs <code>size</code> removes at position, <code>where</code>, on
* an ArrayList of size, <code>size</code>.
*
* @gwt.benchmark.param where = Position.positions2
* @gwt.benchmark.param size -limit = insertRemoveRange
*/
public void testArrayListRemoves(Position where, Integer size) {
removeFromCollection(size, where, list);
}
// Required for JUnit
public void testArrayListRemoves() {
}
/**
* Appends <code>size</code> items to an empty Vector.
*
* @gwt.benchmark.param size -limit = baseRange
*/
public void testVectorAdds(Integer size) {
int num = size.intValue();
for (int i = 0; i < num; i++) {
vector.add("hello");
}
}
// Required for JUnit
public void testVectorAdds() {
}
/**
* Performs <code>size</code> gets on a Vector of size, <code>size</code>.
*
* @gwt.benchmark.param size -limit = baseRange
*/
public void testVectorGets(Integer size) {
int num = size.intValue();
for (int i = 0; i < num; i++) {
vector.get(i);
}
}
// Required for JUnit
public void testVectorGets() {
}
/**
* Performs <code>size</code> inserts at position, <code>where</code>, on
* an empty Vector.
*
* @gwt.benchmark.param where = Position.positions
* @gwt.benchmark.param size -limit = insertRemoveRange
*/
public void testVectorInserts(Position where, Integer size) {
insertIntoCollection(size, where, vector);
}
// Required for JUnit
public void testVectorInserts() {
}
/**
* Performs <code>size</code> removes at position, <code>where</code>, on
* a Vector of size, <code>size</code>.
*
* @gwt.benchmark.param where = Position.positions2
* @gwt.benchmark.param size -limit = insertRemoveRange
*/
public void testVectorRemoves(Position where, Integer size) {
removeFromCollection(size, where, vector);
}
// Required for JUnit
public void testVectorRemoves() {
}
void beginArrayListAdds(Integer size) {
list = new ArrayList();
}
void beginArrayListGets(Integer size) {
createArrayList(size);
}
void beginArrayListInserts(Position where, Integer size) {
list = new ArrayList();
index = 0;
}
void beginArrayListRemoves(Position where, Integer size) {
beginArrayListInserts(where, size);
testArrayListInserts(where, size);
}
void beginVectorAdds(Integer size) {
vector = new Vector();
}
void beginVectorGets(Integer size) {
createVector(size);
}
void beginVectorInserts(Position where, Integer size) {
vector = new Vector();
index = 0;
}
void beginVectorRemoves(Position where, Integer size) {
beginVectorInserts(where, size);
testVectorInserts(where, size);
}
private void createArrayList(Integer size) {
beginArrayListAdds(size);
testArrayListAdds(size);
}
private void createVector(Integer size) {
beginVectorAdds(size);
testVectorAdds(size);
}
private void insertIntoCollection(Integer size, Position where, List v) {
int num = size.intValue();
for (int i = 0; i < num; i++) {
if (where == Position.NONE) {
v.add("hello");
} else if (where == Position.BEGIN) {
v.add(0, "hello");
} else if (where == Position.END) {
v.add(v.size(), "hello");
} else if (where == Position.VARIED) {
v.add(index, "hello");
index += PRIME;
index %= v.size();
}
}
}
private int removeFromCollection(Integer size, Position where, List v) {
int num = size.intValue();
for (int i = 0; i < num; i++) {
if (where == Position.NONE) {
throw new RuntimeException("cannot remove with no position");
} else if (where == Position.BEGIN) {
v.remove(0);
} else if (where == Position.END) {
v.remove(v.size() - 1);
} else if (where == Position.VARIED) {
v.remove(index);
index += PRIME;
int currentSize = v.size();
if (currentSize > 0) {
index %= v.size();
}
}
}
return index;
}
}