Java tutorial
/** * 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.mahout.benchmark; import java.io.IOException; import java.text.DecimalFormat; import java.util.BitSet; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Random; import java.util.concurrent.TimeUnit; import java.util.regex.Pattern; import org.apache.commons.cli2.CommandLine; import org.apache.commons.cli2.Group; import org.apache.commons.cli2.Option; import org.apache.commons.cli2.OptionException; import org.apache.commons.cli2.builder.ArgumentBuilder; import org.apache.commons.cli2.builder.DefaultOptionBuilder; import org.apache.commons.cli2.builder.GroupBuilder; import org.apache.commons.cli2.commandline.Parser; import org.apache.commons.lang3.StringUtils; import org.apache.mahout.benchmark.BenchmarkRunner.BenchmarkFn; import org.apache.mahout.common.CommandLineUtil; import org.apache.mahout.common.RandomUtils; import org.apache.mahout.common.TimingStatistics; import org.apache.mahout.common.commandline.DefaultOptionCreator; import org.apache.mahout.common.distance.ChebyshevDistanceMeasure; import org.apache.mahout.common.distance.CosineDistanceMeasure; import org.apache.mahout.common.distance.EuclideanDistanceMeasure; import org.apache.mahout.common.distance.ManhattanDistanceMeasure; import org.apache.mahout.common.distance.MinkowskiDistanceMeasure; import org.apache.mahout.common.distance.SquaredEuclideanDistanceMeasure; import org.apache.mahout.common.distance.TanimotoDistanceMeasure; import org.apache.mahout.math.DenseVector; import org.apache.mahout.math.RandomAccessSparseVector; import org.apache.mahout.math.SequentialAccessSparseVector; import org.apache.mahout.math.Vector; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.collect.Lists; import com.google.common.collect.Maps; public class VectorBenchmarks { private static final int MAX_TIME_MS = 5000; private static final int LEAD_TIME_MS = 15000; public static final String CLUSTERS = "Clusters"; public static final String CREATE_INCREMENTALLY = "Create (incrementally)"; public static final String CREATE_COPY = "Create (copy)"; public static final String DENSE_FN_SEQ = "Dense.fn(Seq)"; public static final String RAND_FN_DENSE = "Rand.fn(Dense)"; public static final String SEQ_FN_RAND = "Seq.fn(Rand)"; public static final String RAND_FN_SEQ = "Rand.fn(Seq)"; public static final String SEQ_FN_DENSE = "Seq.fn(Dense)"; public static final String DENSE_FN_RAND = "Dense.fn(Rand)"; public static final String SEQ_SPARSE_VECTOR = "SeqSparseVector"; public static final String RAND_SPARSE_VECTOR = "RandSparseVector"; public static final String DENSE_VECTOR = "DenseVector"; private static final Logger log = LoggerFactory.getLogger(VectorBenchmarks.class); private static final Pattern TAB_NEWLINE_PATTERN = Pattern.compile("[\n\t]"); private static final String[] EMPTY = new String[0]; private static final DecimalFormat DF = new DecimalFormat("#.##"); /* package private */ final Vector[][] vectors; final Vector[] clusters; final int cardinality; final int numNonZeros; final int numVectors; final int numClusters; final int loop = Integer.MAX_VALUE; final int opsPerUnit; final long maxTimeUsec; final long leadTimeUsec; private final List<Vector> randomVectors = Lists.newArrayList(); private final List<int[]> randomVectorIndices = Lists.newArrayList(); private final List<double[]> randomVectorValues = Lists.newArrayList(); private final Map<String, Integer> implType = Maps.newHashMap(); private final Map<String, List<String[]>> statsMap = Maps.newHashMap(); private final BenchmarkRunner runner; private final Random r = RandomUtils.getRandom(); public VectorBenchmarks(int cardinality, int numNonZeros, int numVectors, int numClusters, int opsPerUnit) { runner = new BenchmarkRunner(LEAD_TIME_MS, MAX_TIME_MS); maxTimeUsec = TimeUnit.MILLISECONDS.toNanos(MAX_TIME_MS); leadTimeUsec = TimeUnit.MILLISECONDS.toNanos(LEAD_TIME_MS); this.cardinality = cardinality; this.numNonZeros = numNonZeros; this.numVectors = numVectors; this.numClusters = numClusters; this.opsPerUnit = opsPerUnit; setUpVectors(cardinality, numNonZeros, numVectors); vectors = new Vector[3][numVectors]; clusters = new Vector[numClusters]; } private void setUpVectors(int cardinality, int numNonZeros, int numVectors) { for (int i = 0; i < numVectors; i++) { Vector v = new SequentialAccessSparseVector(cardinality, numNonZeros); // sparsity! BitSet featureSpace = new BitSet(cardinality); int[] indexes = new int[numNonZeros]; double[] values = new double[numNonZeros]; int j = 0; while (j < numNonZeros) { double value = r.nextGaussian(); int index = r.nextInt(cardinality); if (!featureSpace.get(index) && value != 0) { featureSpace.set(index); indexes[j] = index; values[j++] = value; v.set(index, value); } } randomVectorIndices.add(indexes); randomVectorValues.add(values); randomVectors.add(v); } } void printStats(TimingStatistics stats, String benchmarkName, String implName, String content) { printStats(stats, benchmarkName, implName, content, 1); } void printStats(TimingStatistics stats, String benchmarkName, String implName) { printStats(stats, benchmarkName, implName, "", 1); } private void printStats(TimingStatistics stats, String benchmarkName, String implName, String content, int multiplier) { float speed = multiplier * stats.getNCalls() * (numNonZeros * 1000.0f * 12 / stats.getSumTime()); float opsPerSec = stats.getNCalls() * 1000000000.0f / stats.getSumTime(); log.info("{} {} \n{} {} \nOps = {} Units/sec\nIOps = {} MBytes/sec", benchmarkName, implName, content, stats.toString(), DF.format(opsPerSec), DF.format(speed)); if (!implType.containsKey(implName)) { implType.put(implName, implType.size()); } int implId = implType.get(implName); if (!statsMap.containsKey(benchmarkName)) { statsMap.put(benchmarkName, Lists.<String[]>newArrayList()); } List<String[]> implStats = statsMap.get(benchmarkName); while (implStats.size() < implId + 1) { implStats.add(EMPTY); } implStats.set(implId, TAB_NEWLINE_PATTERN.split( stats + "\tSpeed = " + DF.format(opsPerSec) + " /sec\tRate = " + DF.format(speed) + " MB/s")); } public void createData() { for (int i = 0; i < Math.max(numVectors, numClusters); ++i) { vectors[0][vIndex(i)] = new DenseVector(randomVectors.get(vIndex(i))); vectors[1][vIndex(i)] = new RandomAccessSparseVector(randomVectors.get(vIndex(i))); vectors[2][vIndex(i)] = new SequentialAccessSparseVector(randomVectors.get(vIndex(i))); if (numClusters > 0) { clusters[cIndex(i)] = new RandomAccessSparseVector(randomVectors.get(vIndex(i))); } } } public void createBenchmark() { printStats(runner.benchmark(new BenchmarkFn() { @Override public Boolean apply(Integer i) { vectors[0][vIndex(i)] = new DenseVector(randomVectors.get(vIndex(i))); return depends(vectors[0][vIndex(i)]); } }), CREATE_COPY, DENSE_VECTOR); printStats(runner.benchmark(new BenchmarkFn() { @Override public Boolean apply(Integer i) { vectors[1][vIndex(i)] = new RandomAccessSparseVector(randomVectors.get(vIndex(i))); return depends(vectors[1][vIndex(i)]); } }), CREATE_COPY, RAND_SPARSE_VECTOR); printStats(runner.benchmark(new BenchmarkFn() { @Override public Boolean apply(Integer i) { vectors[2][vIndex(i)] = new SequentialAccessSparseVector(randomVectors.get(vIndex(i))); return depends(vectors[2][vIndex(i)]); } }), CREATE_COPY, SEQ_SPARSE_VECTOR); if (numClusters > 0) { printStats(runner.benchmark(new BenchmarkFn() { @Override public Boolean apply(Integer i) { clusters[cIndex(i)] = new RandomAccessSparseVector(randomVectors.get(vIndex(i))); return depends(clusters[cIndex(i)]); } }), CREATE_COPY, CLUSTERS); } } private boolean buildVectorIncrementally(TimingStatistics stats, int randomIndex, Vector v, boolean useSetQuick) { int[] indexes = randomVectorIndices.get(randomIndex); double[] values = randomVectorValues.get(randomIndex); List<Integer> randomOrder = Lists.newArrayList(); for (int i = 0; i < indexes.length; i++) { randomOrder.add(i); } Collections.shuffle(randomOrder); int[] permutation = new int[randomOrder.size()]; for (int i = 0; i < randomOrder.size(); i++) { permutation[i] = randomOrder.get(i); } TimingStatistics.Call call = stats.newCall(leadTimeUsec); if (useSetQuick) { for (int i : permutation) { v.setQuick(indexes[i], values[i]); } } else { for (int i : permutation) { v.set(indexes[i], values[i]); } } return call.end(maxTimeUsec); } public void incrementalCreateBenchmark() { TimingStatistics stats = new TimingStatistics(); for (int i = 0; i < loop; i++) { vectors[0][vIndex(i)] = new DenseVector(cardinality); if (buildVectorIncrementally(stats, vIndex(i), vectors[0][vIndex(i)], false)) { break; } } printStats(stats, CREATE_INCREMENTALLY, DENSE_VECTOR); stats = new TimingStatistics(); for (int i = 0; i < loop; i++) { vectors[1][vIndex(i)] = new RandomAccessSparseVector(cardinality); if (buildVectorIncrementally(stats, vIndex(i), vectors[1][vIndex(i)], false)) { break; } } printStats(stats, CREATE_INCREMENTALLY, RAND_SPARSE_VECTOR); stats = new TimingStatistics(); for (int i = 0; i < loop; i++) { vectors[2][vIndex(i)] = new SequentialAccessSparseVector(cardinality); if (buildVectorIncrementally(stats, vIndex(i), vectors[2][vIndex(i)], false)) { break; } } printStats(stats, CREATE_INCREMENTALLY, SEQ_SPARSE_VECTOR); if (numClusters > 0) { stats = new TimingStatistics(); for (int i = 0; i < loop; i++) { clusters[cIndex(i)] = new RandomAccessSparseVector(cardinality); if (buildVectorIncrementally(stats, vIndex(i), clusters[cIndex(i)], false)) { break; } } printStats(stats, CREATE_INCREMENTALLY, CLUSTERS); } } public int vIndex(int i) { return i % numVectors; } public int cIndex(int i) { return i % numClusters; } public static void main(String[] args) throws IOException { DefaultOptionBuilder obuilder = new DefaultOptionBuilder(); ArgumentBuilder abuilder = new ArgumentBuilder(); GroupBuilder gbuilder = new GroupBuilder(); Option vectorSizeOpt = obuilder.withLongName("vectorSize").withRequired(false) .withArgument(abuilder.withName("vs").withDefault(1000000).create()) .withDescription("Cardinality of the vector. Default: 1000000").withShortName("vs").create(); Option numNonZeroOpt = obuilder.withLongName("numNonZero").withRequired(false) .withArgument(abuilder.withName("nz").withDefault(1000).create()) .withDescription("Size of the vector. Default: 1000").withShortName("nz").create(); Option numVectorsOpt = obuilder.withLongName("numVectors").withRequired(false) .withArgument(abuilder.withName("nv").withDefault(25).create()) .withDescription("Number of Vectors to create. Default: 25").withShortName("nv").create(); Option numClustersOpt = obuilder.withLongName("numClusters").withRequired(false) .withArgument(abuilder.withName("nc").withDefault(0).create()) .withDescription( "Number of clusters to create. Set to non zero to run cluster benchmark. Default: 0") .withShortName("nc").create(); Option numOpsOpt = obuilder.withLongName("numOps").withRequired(false) .withArgument(abuilder.withName("numOps").withDefault(10).create()) .withDescription("Number of operations to do per timer. " + "E.g In distance measure, the distance is calculated numOps times" + " and the total time is measured. Default: 10") .withShortName("no").create(); Option helpOpt = DefaultOptionCreator.helpOption(); Group group = gbuilder.withName("Options").withOption(vectorSizeOpt).withOption(numNonZeroOpt) .withOption(numVectorsOpt).withOption(numOpsOpt).withOption(numClustersOpt).withOption(helpOpt) .create(); try { Parser parser = new Parser(); parser.setGroup(group); CommandLine cmdLine = parser.parse(args); if (cmdLine.hasOption(helpOpt)) { CommandLineUtil.printHelpWithGenericOptions(group); return; } int cardinality = 1000000; if (cmdLine.hasOption(vectorSizeOpt)) { cardinality = Integer.parseInt((String) cmdLine.getValue(vectorSizeOpt)); } int numClusters = 0; if (cmdLine.hasOption(numClustersOpt)) { numClusters = Integer.parseInt((String) cmdLine.getValue(numClustersOpt)); } int numNonZero = 1000; if (cmdLine.hasOption(numNonZeroOpt)) { numNonZero = Integer.parseInt((String) cmdLine.getValue(numNonZeroOpt)); } int numVectors = 25; if (cmdLine.hasOption(numVectorsOpt)) { numVectors = Integer.parseInt((String) cmdLine.getValue(numVectorsOpt)); } int numOps = 10; if (cmdLine.hasOption(numOpsOpt)) { numOps = Integer.parseInt((String) cmdLine.getValue(numOpsOpt)); } VectorBenchmarks mark = new VectorBenchmarks(cardinality, numNonZero, numVectors, numClusters, numOps); runBenchmark(mark); // log.info("\n{}", mark); log.info("\n{}", mark.asCsvString()); } catch (OptionException e) { CommandLineUtil.printHelp(group); } } private static void runBenchmark(VectorBenchmarks mark) throws IOException { // Required to set up data. mark.createData(); mark.createBenchmark(); if (mark.cardinality < 200000) { // Too slow. mark.incrementalCreateBenchmark(); } new CloneBenchmark(mark).benchmark(); new DotBenchmark(mark).benchmark(); new PlusBenchmark(mark).benchmark(); new MinusBenchmark(mark).benchmark(); new TimesBenchmark(mark).benchmark(); new SerializationBenchmark(mark).benchmark(); DistanceBenchmark distanceBenchmark = new DistanceBenchmark(mark); distanceBenchmark.benchmark(new CosineDistanceMeasure()); distanceBenchmark.benchmark(new SquaredEuclideanDistanceMeasure()); distanceBenchmark.benchmark(new EuclideanDistanceMeasure()); distanceBenchmark.benchmark(new ManhattanDistanceMeasure()); distanceBenchmark.benchmark(new TanimotoDistanceMeasure()); distanceBenchmark.benchmark(new ChebyshevDistanceMeasure()); distanceBenchmark.benchmark(new MinkowskiDistanceMeasure()); if (mark.numClusters > 0) { ClosestCentroidBenchmark centroidBenchmark = new ClosestCentroidBenchmark(mark); centroidBenchmark.benchmark(new CosineDistanceMeasure()); centroidBenchmark.benchmark(new SquaredEuclideanDistanceMeasure()); centroidBenchmark.benchmark(new EuclideanDistanceMeasure()); centroidBenchmark.benchmark(new ManhattanDistanceMeasure()); centroidBenchmark.benchmark(new TanimotoDistanceMeasure()); centroidBenchmark.benchmark(new ChebyshevDistanceMeasure()); centroidBenchmark.benchmark(new MinkowskiDistanceMeasure()); } } private String asCsvString() { List<String> keys = Lists.newArrayList(statsMap.keySet()); Collections.sort(keys); Map<Integer, String> implMap = Maps.newHashMap(); for (Entry<String, Integer> e : implType.entrySet()) { implMap.put(e.getValue(), e.getKey()); } StringBuilder sb = new StringBuilder(1000); for (String benchmarkName : keys) { int i = 0; for (String[] stats : statsMap.get(benchmarkName)) { if (stats.length < 8) { continue; } sb.append(benchmarkName).append(','); sb.append(implMap.get(i++)).append(','); sb.append(stats[7].trim().split("=|/")[1].trim()); sb.append('\n'); } } sb.append('\n'); return sb.toString(); } @Override public String toString() { int pad = 24; StringBuilder sb = new StringBuilder(1000); sb.append(StringUtils.rightPad("BenchMarks", pad)); for (int i = 0; i < implType.size(); i++) { for (Entry<String, Integer> e : implType.entrySet()) { if (e.getValue() == i) { sb.append(StringUtils.rightPad(e.getKey(), pad).substring(0, pad)); break; } } } sb.append('\n'); List<String> keys = Lists.newArrayList(statsMap.keySet()); Collections.sort(keys); for (String benchmarkName : keys) { List<String[]> implTokenizedStats = statsMap.get(benchmarkName); int maxStats = 0; for (String[] stat : implTokenizedStats) { maxStats = Math.max(maxStats, stat.length); } for (int i = 0; i < maxStats; i++) { boolean printedName = false; for (String[] stats : implTokenizedStats) { if (i == 0 && !printedName) { sb.append(StringUtils.rightPad(benchmarkName, pad)); printedName = true; } else if (!printedName) { printedName = true; sb.append(StringUtils.rightPad("", pad)); } if (stats.length > i) { sb.append(StringUtils.rightPad(stats[i], pad)); } else { sb.append(StringUtils.rightPad("", pad)); } } sb.append('\n'); } sb.append('\n'); } return sb.toString(); } public BenchmarkRunner getRunner() { return runner; } }