Utf8EncodingBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/buffer/Utf8EncodingBenchmark.java lines 39–278

@Fork(value = 2, jvmArgsAppend = "-XX:MaxInlineLevel=9")
public class Utf8EncodingBenchmark extends AbstractMicrobenchmark {
    private static class AnotherCharSequence implements CharSequence {
        private final char[] chars;

        AnotherCharSequence(String chars) {
            this.chars = new char[chars.length()];
            chars.getChars(0, chars.length(), this.chars, 0);
        }

        @Override
        public int length() {
            return chars.length;
        }

        @Override
        public char charAt(int i) {
            return chars[i];
        }

        @Override
        public CharSequence subSequence(int start, int end) {
            throw new UnsupportedOperationException();
        }

        @Override
        public String toString() {
            throw new UnsupportedOperationException();
        }
    }

    // experiment test input
    private String[] strings;
    private StringBuilder[] stringBuilders;
    private AnotherCharSequence[] anotherCharSequences;
    private AsciiString[] asciiStrings;

    @Param({
            "true",
            "false",
    })
    private boolean direct;
    private ByteBuf buffer;

    @Param({
            "true",
            "false",
    })
    private boolean noUnsafe;
    private int dataSetLength;

    @Setup
    public void init() {
        System.setProperty("io.netty.noUnsafe", Boolean.valueOf(noUnsafe).toString());
        int maxExpectedSize = 0;
        List<String> strings = new ArrayList<String>();
        List<StringBuilder> stringBuilders = new ArrayList<StringBuilder>();
        List<AnotherCharSequence> anotherCharSequenceList = new ArrayList<AnotherCharSequence>();
        List<AsciiString> asciiStrings = new ArrayList<AsciiString>();
        try (InputStream testTextStream = getClass().getResourceAsStream("/Utf8Samples.txt");
             InputStreamReader inStreamReader = new InputStreamReader(testTextStream, "UTF-8");
             BufferedReader buffReader = new BufferedReader(inStreamReader);) {

            String line;
            while ((line = buffReader.readLine()) != null) {
                strings.add(line);
                stringBuilders.add(new StringBuilder(line));
                anotherCharSequenceList.add(new AnotherCharSequence(line));
                asciiStrings.add(new AsciiString(line));
                maxExpectedSize = Math.max(maxExpectedSize, ByteBufUtil.utf8MaxBytes(line.length()));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        buffer = direct? Unpooled.directBuffer(maxExpectedSize, maxExpectedSize) :
                Unpooled.buffer(maxExpectedSize, maxExpectedSize);
        buffer.setByte(maxExpectedSize - 1, 0);
        this.strings = strings.toArray(new String[strings.size()]);
        this.stringBuilders = stringBuilders.toArray(new StringBuilder[stringBuilders.size()]);
        this.anotherCharSequences =
                anotherCharSequenceList.toArray(new AnotherCharSequence[anotherCharSequenceList.size()]);