PageRenderTime 26ms CodeModel.GetById 11ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/thirdparty/breakpad/third_party/protobuf/protobuf/benchmarks/ProtoBench.java

http://github.com/tomahawk-player/tomahawk
Java | 203 lines | 144 code | 15 blank | 44 comment | 9 complexity | de22de601c268aaee37c844d5aee612c MD5 | raw file
  1// Protocol Buffers - Google's data interchange format
  2// Copyright 2009 Google Inc.  All rights reserved.
  3// http://code.google.com/p/protobuf/
  4//
  5// Redistribution and use in source and binary forms, with or without
  6// modification, are permitted provided that the following conditions are
  7// met:
  8//
  9//     * Redistributions of source code must retain the above copyright
 10// notice, this list of conditions and the following disclaimer.
 11//     * Redistributions in binary form must reproduce the above
 12// copyright notice, this list of conditions and the following disclaimer
 13// in the documentation and/or other materials provided with the
 14// distribution.
 15//     * Neither the name of Google Inc. nor the names of its
 16// contributors may be used to endorse or promote products derived from
 17// this software without specific prior written permission.
 18//
 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30
 31package com.google.protocolbuffers;
 32
 33import java.io.ByteArrayInputStream;
 34import java.io.ByteArrayOutputStream;
 35import java.io.File;
 36import java.io.FileOutputStream;
 37import java.io.FileNotFoundException;
 38import java.io.IOException;
 39import java.io.RandomAccessFile;
 40import java.lang.reflect.Method;
 41
 42import com.google.protobuf.ByteString;
 43import com.google.protobuf.CodedInputStream;
 44import com.google.protobuf.CodedOutputStream;
 45import com.google.protobuf.Message;
 46
 47public class ProtoBench {
 48  
 49  private static final long MIN_SAMPLE_TIME_MS = 2 * 1000;
 50  private static final long TARGET_TIME_MS = 30 * 1000;
 51
 52  private ProtoBench() {
 53    // Prevent instantiation
 54  }
 55  
 56  public static void main(String[] args) {
 57    if (args.length < 2 || (args.length % 2) != 0) {
 58      System.err.println("Usage: ProtoBench <descriptor type name> <input data>");
 59      System.err.println("The descriptor type name is the fully-qualified message name,");
 60      System.err.println("e.g. com.google.protocolbuffers.benchmark.Message1");
 61      System.err.println("(You can specify multiple pairs of descriptor type name and input data.)");
 62      System.exit(1);
 63    }
 64    boolean success = true;
 65    for (int i = 0; i < args.length; i += 2) {
 66      success &= runTest(args[i], args[i + 1]);
 67    }
 68    System.exit(success ? 0 : 1);
 69  }
 70
 71  /**
 72   * Runs a single test. Error messages are displayed to stderr, and the return value
 73   * indicates general success/failure.
 74   */
 75  public static boolean runTest(String type, String file) {
 76    System.out.println("Benchmarking " + type + " with file " + file);
 77    final Message defaultMessage;
 78    try {
 79      Class<?> clazz = Class.forName(type);
 80      Method method = clazz.getDeclaredMethod("getDefaultInstance");
 81      defaultMessage = (Message) method.invoke(null);
 82    } catch (Exception e) {
 83      // We want to do the same thing with all exceptions. Not generally nice,
 84      // but this is slightly different.
 85      System.err.println("Unable to get default message for " + type);
 86      return false;
 87    }
 88    
 89    try {
 90      final byte[] inputData = readAllBytes(file);
 91      final ByteArrayInputStream inputStream = new ByteArrayInputStream(inputData);
 92      final ByteString inputString = ByteString.copyFrom(inputData);
 93      final Message sampleMessage = defaultMessage.newBuilderForType().mergeFrom(inputString).build();
 94      FileOutputStream devNullTemp = null;
 95      CodedOutputStream reuseDevNullTemp = null;
 96      try {
 97        devNullTemp = new FileOutputStream("/dev/null");
 98        reuseDevNullTemp = CodedOutputStream.newInstance(devNullTemp);
 99      } catch (FileNotFoundException e) {
100        // ignore: this is probably Windows, where /dev/null does not exist
101      }
102      final FileOutputStream devNull = devNullTemp;
103      final CodedOutputStream reuseDevNull = reuseDevNullTemp;
104      benchmark("Serialize to byte string", inputData.length, new Action() {
105        public void execute() { sampleMessage.toByteString(); }
106      });      
107      benchmark("Serialize to byte array", inputData.length, new Action() {
108        public void execute() { sampleMessage.toByteArray(); }
109      });
110      benchmark("Serialize to memory stream", inputData.length, new Action() {
111        public void execute() throws IOException { 
112          sampleMessage.writeTo(new ByteArrayOutputStream()); 
113        }
114      });
115      if (devNull != null) {
116        benchmark("Serialize to /dev/null with FileOutputStream", inputData.length, new Action() {
117          public void execute() throws IOException {
118            sampleMessage.writeTo(devNull);
119          }
120        });
121        benchmark("Serialize to /dev/null reusing FileOutputStream", inputData.length, new Action() {
122          public void execute() throws IOException {
123            sampleMessage.writeTo(reuseDevNull);
124            reuseDevNull.flush();  // force the write to the OutputStream
125          }
126        });
127      }
128      benchmark("Deserialize from byte string", inputData.length, new Action() {
129        public void execute() throws IOException { 
130          defaultMessage.newBuilderForType().mergeFrom(inputString).build();
131        }
132      });
133      benchmark("Deserialize from byte array", inputData.length, new Action() {
134        public void execute() throws IOException { 
135          defaultMessage.newBuilderForType()
136            .mergeFrom(CodedInputStream.newInstance(inputData)).build();
137        }
138      });
139      benchmark("Deserialize from memory stream", inputData.length, new Action() {
140        public void execute() throws IOException { 
141          defaultMessage.newBuilderForType()
142            .mergeFrom(CodedInputStream.newInstance(inputStream)).build();
143          inputStream.reset();
144        }
145      });
146      System.out.println();
147      return true;
148    } catch (Exception e) {
149      System.err.println("Error: " + e.getMessage());
150      System.err.println("Detailed exception information:");
151      e.printStackTrace(System.err);
152      return false;
153    }
154  }
155  
156  private static void benchmark(String name, long dataSize, Action action) throws IOException {
157    // Make sure it's JITted "reasonably" hard before running the first progress test
158    for (int i=0; i < 100; i++) {
159      action.execute();
160    }
161    
162    // Run it progressively more times until we've got a reasonable sample
163    int iterations = 1;
164    long elapsed = timeAction(action, iterations);
165    while (elapsed < MIN_SAMPLE_TIME_MS) {
166      iterations *= 2;
167      elapsed = timeAction(action, iterations);
168    }
169    
170    // Upscale the sample to the target time. Do this in floating point arithmetic
171    // to avoid overflow issues.
172    iterations = (int) ((TARGET_TIME_MS / (double) elapsed) * iterations);
173    elapsed = timeAction(action, iterations);
174    System.out.println(name + ": " + iterations + " iterations in "
175         + (elapsed/1000f) + "s; " 
176         + (iterations * dataSize) / (elapsed * 1024 * 1024 / 1000f) 
177         + "MB/s");
178  }
179  
180  private static long timeAction(Action action, int iterations) throws IOException {
181    System.gc();    
182    long start = System.currentTimeMillis();
183    for (int i = 0; i < iterations; i++) {
184      action.execute();
185    }
186    long end = System.currentTimeMillis();
187    return end - start;
188  }
189  
190  private static byte[] readAllBytes(String filename) throws IOException {
191    RandomAccessFile file = new RandomAccessFile(new File(filename), "r");
192    byte[] content = new byte[(int) file.length()];
193    file.readFully(content);
194    return content;
195  }
196
197  /**
198   * Interface used to capture a single action to benchmark.
199   */
200  interface Action {
201    void execute() throws IOException;
202  }
203}