Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Adding benchmark for PathMappings

This commit is contained in:
Joakim Erdfelt 2013-04-17 11:17:27 -07:00
parent b2e675ebad
commit 43459d4b33
1 changed files with 222 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
jetty-websocket/javax-websocket-server-impl/src/test/java/org/eclipse/jetty/websocket/jsr356/server/pathmap/PathMappingsBenchmarkTest.java Normal file
View File

@ -0,0 +1,222 @@
//
// ========================================================================
// Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.websocket.jsr356.server.pathmap;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import org.eclipse.jetty.http.PathMap;
import org.eclipse.jetty.toolchain.test.AdvancedRunner;
import org.eclipse.jetty.toolchain.test.annotation.Stress;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(AdvancedRunner.class)
public class PathMappingsBenchmarkTest
{
public static abstract class AbstractPathMapThread extends Thread
{
private int iterations;
private CyclicBarrier barrier;
private long success;
private long error;
public AbstractPathMapThread(int iterations, CyclicBarrier barrier)
{
this.iterations = iterations;
this.barrier = barrier;
}
public abstract String getMatchedResource(String path);
@Override
public void run()
{
int llen = LOOKUPS.length;
String path;
String expectedResource;
String matchedResource;
await(barrier);
for (int iter = 0; iter < iterations; iter++)
{
for (int li = 0; li < llen; li++)
{
path = LOOKUPS[li][0];
expectedResource = LOOKUPS[li][1];
matchedResource = getMatchedResource(path);
if (matchedResource.equals(expectedResource))
{
success++;
}
else
{
error++;
}
}
}
await(barrier);
}
}
public static class PathMapMatchThread extends AbstractPathMapThread
{
private PathMap<String> pathmap;
public PathMapMatchThread(PathMap<String> pathmap, int iters, CyclicBarrier barrier)
{
super(iters,barrier);
this.pathmap = pathmap;
}
@Override
public String getMatchedResource(String path)
{
return pathmap.getMatch(path).getValue();
}
}
public static class PathMatchThread extends AbstractPathMapThread
{
private PathMappings<String> pathmap;
public PathMatchThread(PathMappings<String> pathmap, int iters, CyclicBarrier barrier)
{
super(iters,barrier);
this.pathmap = pathmap;
}
@Override
public String getMatchedResource(String path)
{
return pathmap.getMatch(path).getResource();
}
}
private static final Logger LOG = Log.getLogger(PathMappingsBenchmarkTest.class);
private static final String[][] LOOKUPS;
private int runs = 10;
private int threads = 100;
private int iters = 1000;
static
{
LOOKUPS = new String[][]
{
// @formatter:off
{ "/abs/path", "path" },
{ "/abs/path/longer","longpath" },
{ "/abs/path/foo","default" },
{ "/main.css","default" },
{ "/downloads/script.gz","gzipped" },
{ "/downloads/distribution.tar.gz","tarball" },
{ "/downloads/readme.txt","default" },
{ "/downloads/logs.tgz","default" },
{ "/animal/horse/mustang","animals" },
{ "/animal/bird/eagle/bald","birds" },
{ "/animal/fish/shark/hammerhead","fishes" },
{ "/animal/insect/ladybug","animals" },
// @formatter:on
};
}
private static void await(CyclicBarrier barrier)
{
try
{
barrier.await();
}
catch (Exception x)
{
throw new RuntimeException(x);
}
}
@Stress("High CPU")
@Test
public void testServletPathMap()
{
// Setup (old) PathMap
PathMap<String> p = new PathMap<>();
p.put("/abs/path","path");
p.put("/abs/path/longer","longpath");
p.put("/animal/bird/*","birds");
p.put("/animal/fish/*","fishes");
p.put("/animal/*","animals");
p.put("*.tar.gz","tarball");
p.put("*.gz","gzipped");
p.put("/","default");
final CyclicBarrier barrier = new CyclicBarrier(threads + 1);
for (int r = 0; r < runs; r++)
{
for (int t = 0; t < threads; t++)
{
PathMapMatchThread thread = new PathMapMatchThread(p,iters,barrier);
thread.start();
}
await(barrier);
long begin = System.nanoTime();
await(barrier);
long end = System.nanoTime();
long elapsed = TimeUnit.NANOSECONDS.toMillis(end - begin);
int totalMatches = threads * iters * LOOKUPS.length;
LOG.info("PathMap (Servlet only) threads:{}/iters:{}/total-matches:{} => {} ms",threads,iters,totalMatches,elapsed);
}
}
@Stress("High CPU")
@Test
public void testServletPathMappings()
{
// Setup (new) PathMappings
PathMappings<String> p = new PathMappings<>();
p.put(new ServletPathSpec("/abs/path"),"path");
p.put(new ServletPathSpec("/abs/path/longer"),"longpath");
p.put(new ServletPathSpec("/animal/bird/*"),"birds");
p.put(new ServletPathSpec("/animal/fish/*"),"fishes");
p.put(new ServletPathSpec("/animal/*"),"animals");
p.put(new ServletPathSpec("*.tar.gz"),"tarball");
p.put(new ServletPathSpec("*.gz"),"gzipped");
p.put(new ServletPathSpec("/"),"default");
final CyclicBarrier barrier = new CyclicBarrier(threads + 1);
for (int r = 0; r < runs; r++)
{
for (int t = 0; t < threads; t++)
{
PathMatchThread thread = new PathMatchThread(p,iters,barrier);
thread.start();
}
await(barrier);
long begin = System.nanoTime();
await(barrier);
long end = System.nanoTime();
long elapsed = TimeUnit.NANOSECONDS.toMillis(end - begin);
LOG.info("PathMappings (Servlet only) threads:{}/iters:{} => {} ms",threads,iters,elapsed);
}
}
}