|
Java example source code file (HeadersBenchmark.java)
This example Java source code file (HeadersBenchmark.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The HeadersBenchmark.java Java example source code
/*
* Copyright 2015 The Netty Project
*
* The Netty Project 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 io.netty.microbench.headers;
import io.netty.handler.codec.Headers;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http2.DefaultHttp2Headers;
import io.netty.microbench.util.AbstractMicrobenchmark;
import io.netty.util.AsciiString;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Threads(1)
@State(Scope.Benchmark)
@Fork(1)
@Warmup(iterations = 10)
@Measurement(iterations = 10)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class HeadersBenchmark extends AbstractMicrobenchmark {
private static String toHttpName(String name) {
return (name.startsWith(":")) ? name.substring(1) : name;
}
private static String toHttp2Name(String name) {
name = name.toLowerCase();
return (name.equals("host")) ? "xhost" : name;
}
@Param
ExampleHeaders.HeaderExample exampleHeader;
AsciiString[] httpNames;
AsciiString[] http2Names;
AsciiString[] httpValues;
DefaultHttpHeaders httpHeaders;
DefaultHttp2Headers http2Headers;
DefaultHttpHeaders emptyHttpHeaders;
DefaultHttp2Headers emptyHttp2Headers;
DefaultHttpHeaders emptyHttpHeadersNoValidate;
DefaultHttp2Headers emptyHttp2HeadersNoValidate;
SlowHeaders slowHttp2Headers;
@Setup(Level.Trial)
public void setup() {
Map<String, String> headers = ExampleHeaders.EXAMPLES.get(exampleHeader);
httpNames = new AsciiString[headers.size()];
http2Names = new AsciiString[headers.size()];
httpValues = new AsciiString[headers.size()];
httpHeaders = new DefaultHttpHeaders(false);
http2Headers = new DefaultHttp2Headers(false);
int idx = 0;
for (Map.Entry<String, String> header : headers.entrySet()) {
String name = header.getKey();
String httpName = toHttpName(name);
String http2Name = toHttp2Name(name);
String value = header.getValue();
httpNames[idx] = new AsciiString(httpName);
http2Names[idx] = new AsciiString(http2Name);
httpValues[idx] = new AsciiString(value);
httpHeaders.add(httpNames[idx], httpValues[idx]);
http2Headers.add(http2Names[idx], httpValues[idx]);
idx++;
}
slowHttp2Headers = new SlowHeaders(http2Headers);
emptyHttpHeaders = new DefaultHttpHeaders(true);
emptyHttp2Headers = new DefaultHttp2Headers(true);
emptyHttpHeadersNoValidate = new DefaultHttpHeaders(false);
emptyHttp2HeadersNoValidate = new DefaultHttp2Headers(false);
}
@Setup(Level.Invocation)
public void setupEmptyHeaders() {
emptyHttpHeaders.clear();
emptyHttp2Headers .clear();
emptyHttpHeadersNoValidate.clear();
emptyHttp2HeadersNoValidate.clear();
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpRemove(Blackhole bh) {
for (AsciiString name : httpNames) {
bh.consume(httpHeaders.remove(name));
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpGet(Blackhole bh) {
for (AsciiString name : httpNames) {
bh.consume(httpHeaders.get(name));
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public DefaultHttpHeaders httpPut() {
DefaultHttpHeaders headers = new DefaultHttpHeaders(false);
for (int i = 0; i < httpNames.length; i++) {
headers.add(httpNames[i], httpValues[i]);
}
return headers;
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpIterate(Blackhole bh) {
Iterator<Entry itr = httpHeaders.iteratorCharSequence();
while (itr.hasNext()) {
bh.consume(itr.next());
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2Remove(Blackhole bh) {
for (AsciiString name : http2Names) {
bh.consume(http2Headers.remove(name));
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2Get(Blackhole bh) {
for (AsciiString name : http2Names) {
bh.consume(http2Headers.get(name));
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public DefaultHttp2Headers http2Put() {
DefaultHttp2Headers headers = new DefaultHttp2Headers(false);
for (int i = 0; i < http2Names.length; i++) {
headers.add(http2Names[i], httpValues[i]);
}
return headers;
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2Iterate(Blackhole bh) {
for (Entry<CharSequence, CharSequence> entry : http2Headers) {
bh.consume(entry);
}
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpAddAllFastest(Blackhole bh) {
bh.consume(emptyHttpHeadersNoValidate.add(httpHeaders));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpAddAllFast(Blackhole bh) {
bh.consume(emptyHttpHeaders.add(httpHeaders));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2AddAllFastest(Blackhole bh) {
bh.consume(emptyHttp2HeadersNoValidate.add(http2Headers));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2AddAllFast(Blackhole bh) {
bh.consume(emptyHttp2Headers.add(http2Headers));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2AddAllSlow(Blackhole bh) {
bh.consume(emptyHttp2Headers.add(slowHttp2Headers));
}
private static final class SlowHeaders implements Headers<CharSequence, CharSequence, SlowHeaders> {
private final Headers<CharSequence, CharSequence, ? extends Headers> delegate;
private SlowHeaders(Headers<CharSequence, CharSequence, ? extends Headers> delegate) {
this.delegate = delegate;
}
@Override
public CharSequence get(CharSequence name) {
return delegate.get(name);
}
@Override
public CharSequence get(CharSequence name, CharSequence defaultValue) {
return delegate.get(name, defaultValue);
}
@Override
public CharSequence getAndRemove(CharSequence name) {
return delegate.getAndRemove(name);
}
@Override
public CharSequence getAndRemove(CharSequence name, CharSequence defaultValue) {
return delegate.getAndRemove(name, defaultValue);
}
@Override
public List<CharSequence> getAll(CharSequence name) {
return delegate.getAll(name);
}
@Override
public List<CharSequence> getAllAndRemove(CharSequence name) {
return delegate.getAllAndRemove(name);
}
@Override
public Boolean getBoolean(CharSequence name) {
return delegate.getBoolean(name);
}
@Override
public boolean getBoolean(CharSequence name, boolean defaultValue) {
return delegate.getBoolean(name, defaultValue);
}
@Override
public Byte getByte(CharSequence name) {
return delegate.getByte(name);
}
@Override
public byte getByte(CharSequence name, byte defaultValue) {
return delegate.getByte(name, defaultValue);
}
@Override
public Character getChar(CharSequence name) {
return delegate.getChar(name);
}
@Override
public char getChar(CharSequence name, char defaultValue) {
return delegate.getChar(name, defaultValue);
}
@Override
public Short getShort(CharSequence name) {
return delegate.getShort(name);
}
@Override
public short getShort(CharSequence name, short defaultValue) {
return delegate.getShort(name, defaultValue);
}
@Override
public Integer getInt(CharSequence name) {
return delegate.getInt(name);
}
@Override
public int getInt(CharSequence name, int defaultValue) {
return delegate.getInt(name, defaultValue);
}
@Override
public Long getLong(CharSequence name) {
return delegate.getLong(name);
}
@Override
public long getLong(CharSequence name, long defaultValue) {
return delegate.getLong(name, defaultValue);
}
@Override
public Float getFloat(CharSequence name) {
return delegate.getFloat(name);
}
@Override
public float getFloat(CharSequence name, float defaultValue) {
return delegate.getFloat(name, defaultValue);
}
@Override
public Double getDouble(CharSequence name) {
return delegate.getDouble(name);
}
@Override
public double getDouble(CharSequence name, double defaultValue) {
return delegate.getDouble(name, defaultValue);
}
@Override
public Long getTimeMillis(CharSequence name) {
return delegate.getTimeMillis(name);
}
@Override
public long getTimeMillis(CharSequence name, long defaultValue) {
return delegate.getTimeMillis(name, defaultValue);
}
@Override
public Boolean getBooleanAndRemove(CharSequence name) {
return delegate.getBooleanAndRemove(name);
}
@Override
public boolean getBooleanAndRemove(CharSequence name, boolean defaultValue) {
return delegate.getBooleanAndRemove(name, defaultValue);
}
@Override
public Byte getByteAndRemove(CharSequence name) {
return delegate.getByteAndRemove(name);
}
@Override
public byte getByteAndRemove(CharSequence name, byte defaultValue) {
return delegate.getByteAndRemove(name, defaultValue);
}
@Override
public Character getCharAndRemove(CharSequence name) {
return delegate.getCharAndRemove(name);
}
@Override
public char getCharAndRemove(CharSequence name, char defaultValue) {
return delegate.getCharAndRemove(name, defaultValue);
}
@Override
public Short getShortAndRemove(CharSequence name) {
return delegate.getShortAndRemove(name);
}
@Override
public short getShortAndRemove(CharSequence name, short defaultValue) {
return delegate.getShortAndRemove(name, defaultValue);
}
@Override
public Integer getIntAndRemove(CharSequence name) {
return delegate.getIntAndRemove(name);
}
@Override
public int getIntAndRemove(CharSequence name, int defaultValue) {
return delegate.getIntAndRemove(name, defaultValue);
}
@Override
public Long getLongAndRemove(CharSequence name) {
return delegate.getLongAndRemove(name);
}
@Override
public long getLongAndRemove(CharSequence name, long defaultValue) {
return delegate.getLongAndRemove(name, defaultValue);
}
@Override
public Float getFloatAndRemove(CharSequence name) {
return delegate.getFloatAndRemove(name);
}
@Override
public float getFloatAndRemove(CharSequence name, float defaultValue) {
return delegate.getFloatAndRemove(name, defaultValue);
}
@Override
public Double getDoubleAndRemove(CharSequence name) {
return delegate.getDoubleAndRemove(name);
}
@Override
public double getDoubleAndRemove(CharSequence name, double defaultValue) {
return delegate.getDoubleAndRemove(name, defaultValue);
}
@Override
public Long getTimeMillisAndRemove(CharSequence name) {
return delegate.getTimeMillisAndRemove(name);
}
@Override
public long getTimeMillisAndRemove(CharSequence name, long defaultValue) {
return delegate.getTimeMillisAndRemove(name, defaultValue);
}
@Override
public boolean contains(CharSequence name) {
return delegate.contains(name);
}
@Override
public boolean contains(CharSequence name, CharSequence value) {
return delegate.contains(name, value);
}
@Override
public boolean containsObject(CharSequence name, Object value) {
return delegate.containsObject(name, value);
}
@Override
public boolean containsBoolean(CharSequence name, boolean value) {
return delegate.containsBoolean(name, value);
}
@Override
public boolean containsByte(CharSequence name, byte value) {
return delegate.containsByte(name, value);
}
@Override
public boolean containsChar(CharSequence name, char value) {
return delegate.containsChar(name, value);
}
@Override
public boolean containsShort(CharSequence name, short value) {
return delegate.containsShort(name, value);
}
@Override
public boolean containsInt(CharSequence name, int value) {
return delegate.containsInt(name, value);
}
@Override
public boolean containsLong(CharSequence name, long value) {
return delegate.containsLong(name, value);
}
@Override
public boolean containsFloat(CharSequence name, float value) {
return delegate.containsFloat(name, value);
}
@Override
public boolean containsDouble(CharSequence name, double value) {
return delegate.containsDouble(name, value);
}
@Override
public boolean containsTimeMillis(CharSequence name, long value) {
return delegate.containsTimeMillis(name, value);
}
@Override
public int size() {
return delegate.size();
}
@Override
public boolean isEmpty() {
return delegate.isEmpty();
}
@Override
public Set<CharSequence> names() {
return delegate.names();
}
@Override
public SlowHeaders add(CharSequence name, CharSequence value) {
delegate.add(name, value);
return this;
}
@Override
public SlowHeaders add(CharSequence name, Iterable<? extends CharSequence> values) {
delegate.add(name, values);
return this;
}
@Override
public SlowHeaders add(CharSequence name, CharSequence... values) {
delegate.add(name, values);
return this;
}
@Override
public SlowHeaders addObject(CharSequence name, Object value) {
delegate.addObject(name, value);
return this;
}
@Override
public SlowHeaders addObject(CharSequence name, Iterable<?> values) {
delegate.addObject(name, values);
return this;
}
@Override
public SlowHeaders addObject(CharSequence name, Object... values) {
delegate.addObject(name, values);
return this;
}
@Override
public SlowHeaders addBoolean(CharSequence name, boolean value) {
delegate.addBoolean(name, value);
return this;
}
@Override
public SlowHeaders addByte(CharSequence name, byte value) {
delegate.addByte(name, value);
return this;
}
@Override
public SlowHeaders addChar(CharSequence name, char value) {
delegate.addChar(name, value);
return this;
}
@Override
public SlowHeaders addShort(CharSequence name, short value) {
delegate.addShort(name, value);
return this;
}
@Override
public SlowHeaders addInt(CharSequence name, int value) {
delegate.addInt(name, value);
return this;
}
@Override
public SlowHeaders addLong(CharSequence name, long value) {
delegate.addLong(name, value);
return this;
}
@Override
public SlowHeaders addFloat(CharSequence name, float value) {
delegate.addFloat(name, value);
return this;
}
@Override
public SlowHeaders addDouble(CharSequence name, double value) {
delegate.addDouble(name, value);
return this;
}
@Override
public SlowHeaders addTimeMillis(CharSequence name, long value) {
delegate.addTimeMillis(name, value);
return this;
}
@Override
public SlowHeaders add(Headers<? extends CharSequence, ? extends CharSequence, ?> headers) {
delegate.add(headers);
return this;
}
@Override
public SlowHeaders set(CharSequence name, CharSequence value) {
delegate.set(name, value);
return this;
}
@Override
public SlowHeaders set(CharSequence name, Iterable<? extends CharSequence> values) {
delegate.set(name, values);
return this;
}
@Override
public SlowHeaders set(CharSequence name, CharSequence... values) {
delegate.set(name, values);
return this;
}
@Override
public SlowHeaders setObject(CharSequence name, Object value) {
delegate.setObject(name, value);
return this;
}
@Override
public SlowHeaders setObject(CharSequence name, Iterable<?> values) {
delegate.setObject(name, values);
return this;
}
@Override
public SlowHeaders setObject(CharSequence name, Object... values) {
delegate.setObject(name, values);
return this;
}
@Override
public SlowHeaders setBoolean(CharSequence name, boolean value) {
delegate.setBoolean(name, value);
return this;
}
@Override
public SlowHeaders setByte(CharSequence name, byte value) {
delegate.setByte(name, value);
return this;
}
@Override
public SlowHeaders setChar(CharSequence name, char value) {
delegate.setChar(name, value);
return this;
}
@Override
public SlowHeaders setShort(CharSequence name, short value) {
delegate.setShort(name, value);
return this;
}
@Override
public SlowHeaders setInt(CharSequence name, int value) {
delegate.setInt(name, value);
return this;
}
@Override
public SlowHeaders setLong(CharSequence name, long value) {
delegate.setLong(name, value);
return this;
}
@Override
public SlowHeaders setFloat(CharSequence name, float value) {
delegate.setFloat(name, value);
return this;
}
@Override
public SlowHeaders setDouble(CharSequence name, double value) {
delegate.setDouble(name, value);
return this;
}
@Override
public SlowHeaders setTimeMillis(CharSequence name, long value) {
delegate.setTimeMillis(name, value);
return this;
}
@Override
public SlowHeaders set(Headers<? extends CharSequence, ? extends CharSequence, ?> headers) {
delegate.set(headers);
return this;
}
@Override
public SlowHeaders setAll(Headers<? extends CharSequence, ? extends CharSequence, ?> headers) {
delegate.setAll(headers);
return this;
}
@Override
public boolean remove(CharSequence name) {
return delegate.remove(name);
}
@Override
public SlowHeaders clear() {
delegate.clear();
return this;
}
@Override
public Iterator<Entry iterator() {
return delegate.iterator();
}
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java HeadersBenchmark.java source code file:
|