src/test/java/org/apache/commons/csv/CSVBenchmark.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF 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
 *
 *   https://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 org.apache.commons.csv;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;
import java.util.zip.GZIPInputStream;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
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 org.supercsv.io.CsvListReader;
import org.supercsv.prefs.CsvPreference;

import com.generationjava.io.CsvReader;
import com.opencsv.CSVParserBuilder;
import com.opencsv.CSVReaderBuilder;

@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, jvmArgs = {"-server", "-Xms1024M", "-Xmx1024M"})
@Threads(1)
@Warmup(iterations = 5)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
public class CSVBenchmark {

    private static final class CountingReaderCallback implements org.skife.csv.ReaderCallback {
        public int count;

        @Override
        public void onRow(final String[] fields) {
            count++;
        }
    }

    private String data;

    private Reader getReader() {
        return new StringReader(data);
    }

    /**
     * Load the data in memory before running the benchmarks, this takes out IO from the results.
     */
    @Setup
    public void init() throws IOException {
        try (InputStream in = this.getClass().getClassLoader().getResourceAsStream("org/apache/commons/csv/perf/worldcitiespop.txt.gz");
                InputStream gzin = new GZIPInputStream(in, 8192)) {
            this.data = IOUtils.toString(gzin, StandardCharsets.ISO_8859_1);
        }
    }

    @Benchmark
    public int parseCommonsCSV(final Blackhole bh) throws Exception {
        int count = 0;

        try (Reader in = getReader()) {
            final CSVFormat format = CSVFormat.Builder.create().setSkipHeaderRecord(true).build();
            final Iterator<CSVRecord> iter = format.parse(in).iterator();
            while (iter.hasNext()) {
                count++;
                iter.next();
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int parseGenJavaCSV(final Blackhole bh) throws Exception {
        int count = 0;

        try (Reader in = getReader()) {
            final CsvReader reader = new CsvReader(in);
            reader.setFieldDelimiter(',');
            while (reader.readLine() != null) {
                count++;
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int parseJavaCSV(final Blackhole bh) throws Exception {
        int count = 0;

        try (Reader in = getReader()) {
            final com.csvreader.CsvReader reader = new com.csvreader.CsvReader(in, ',');
            reader.setRecordDelimiter('\n');
            while (reader.readRecord()) {
                count++;
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int parseOpenCSV(final Blackhole bh) throws Exception {
        int count = 0;

        final com.opencsv.CSVParser parser = new CSVParserBuilder()
          .withSeparator(',').withIgnoreQuotations(true).build();

        try (Reader in = getReader()) {
            final com.opencsv.CSVReader reader = new CSVReaderBuilder(in).withSkipLines(1).withCSVParser(parser).build();
            while (reader.readNext() != null) {
                count++;
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int parseSkifeCSV(final Blackhole bh) throws Exception {
        final org.skife.csv.CSVReader reader = new org.skife.csv.SimpleReader();
        reader.setSeperator(',');
        final CountingReaderCallback callback = new CountingReaderCallback();

        try (Reader in = getReader()) {
          reader.parse(in, callback);
        }

        bh.consume(callback);
        return callback.count;
    }

    @Benchmark
    public int parseSuperCSV(final Blackhole bh) throws Exception {
        int count = 0;

        try (CsvListReader reader = new CsvListReader(getReader(), CsvPreference.STANDARD_PREFERENCE)) {
            while (reader.read() != null) {
                count++;
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int read(final Blackhole bh) throws Exception {
        int count = 0;

        try (BufferedReader reader = new BufferedReader(getReader())) {
            while (reader.readLine() != null) {
              count++;
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int scan(final Blackhole bh) throws Exception {
        int count = 0;

        try (Scanner scanner = new Scanner(getReader())) {
            while (scanner.hasNextLine()) {
              scanner.nextLine();
              count++;
            }
        }

        bh.consume(count);
        return count;
    }

    @Benchmark
    public int split(final Blackhole bh) throws Exception {
      int count = 0;

      try (BufferedReader reader = new BufferedReader(getReader())) {
          String line;
          while ((line = reader.readLine()) != null) {
            final String[] values = StringUtils.split(line, ',');
            count += values.length;
          }
      }

      bh.consume(count);
      return count;
    }
}