alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

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.

Java - Java tags/keywords

asciistring, benchmark, boolean, byte, character, charsequence, defaulthttp2headers, defaulthttpheaders, iterable, long, object, override, short, slowheaders, threading, threads, util

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:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.