Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package eu.toolchain.async;
  
  import java.util.List;
  
These tests are only in place to verify to a loose degree that we get at least as good performance as Guava.

Author(s):
udoprog
 
 public class PerformanceTests {
     private static final int WARMUP = 100;
     private static final int ITERATIONS = 1000;
 
     private static final Runtime runtime = Runtime.getRuntime();
 
     public static void main(String argv[]) {
         run("many listeners"new ManyListeners.Guava(), new ManyListeners.Tiny());
 
         run("immediate"new Immediate.Guava(), new Immediate.Tiny());
 
         run("immediate, into many transforms"new TransformMany.Guava(), new TransformMany.Tiny());
 
         run("immediate, into few transforms"new TransformFew.Guava(), new TransformFew.Tiny());
 
         run("many threads contending"new ManyThreads.Guava(), new ManyThreads.Tiny());
     }
 
     private static List<LongrunTest(TestCase test) {
         .gc();
 
         final List<Longsamples = new ArrayList<>();
 
         for (int i = 0; i < i++) {
             try {
                 test.test();
             } catch (Exception e) {
             }
         }
 
         final List<Exceptionerrors = new ArrayList<>();
 
         for (int i = 0; i < i++) {
             final long then = System.nanoTime();
 
             try {
                 test.test();
             } catch (Exception e) {
                 errors.add(e);
             }
 
             final long diff = System.nanoTime() - then;
 
             samples.add(diff);
         }
 
         if (!errors.isEmpty()) {
             for (int i = 0; i < errors.size(); i++) {
                 final Exception e = errors.get(i);
                 ..println("Error #" + i + ": " + e.getMessage());
                 e.printStackTrace(.);
             }
 
             throw new IllegalStateException("test threw errors");
         }
 
         Collections.sort(samples);
         return samples;
     }
 
     private static void run(String nameTestCase guavaTestCase tiny) {
         // hint that we want a clean state :).
         final List<Longg = runTest(guava);
         final List<Longt = runTest(tiny);
 
         ..println(name + " (guava - tiny)");
         ..println("  avg: " + time(avg(g)) + " - " + time(avg(t)));
         ..println("  p50: " + time(q(g, 0.5)) + " - " + time(q(t, 0.5)));
         ..println("  p95: " + time(q(g, 0.95)) + " - " + time(q(t, 0.95)));
         ..println("  p99: " + time(q(g, 0.99)) + " - " + time(q(t, 0.99)));
         ..println("  " + Math.round(((doubleavg(g) / (doubleavg(t)) * 100d) + "%");
     }
 
     private static long avg(List<Longsamples) {
         long total = 0;
 
         for (long sample : samples)
             total += sample;
 
         return total / samples.size();
     }
 
    private static long q(List<Longsamplesdouble q) {
        final int target = Math.min((int) Math.round(samples.size() * q), samples.size() - 1);
        return samples.get(target);
    }
    private static String time(long ns) {
        if (ns > 1000000)
            return (Math.round((ns / 1000000d)) / 1000d) + "s";
        if (ns > 1000)
            return (Math.round((ns / 1000d)) / 1000d) + "ms";
        return (ns / 1000d) + "μs";
    }
New to GrepCode? Check out our FAQ X