/**
* 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
*
* 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 org.apache.avro.io;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import org.apache.avro.FooBarSpecificRecord;
import org.apache.avro.Schema;
import org.apache.avro.Schema.Field;
import org.apache.avro.TypeEnum;
import org.apache.avro.generic.GenericData;
import org.apache.avro.generic.GenericDatumReader;
import org.apache.avro.generic.GenericDatumWriter;
import org.apache.avro.generic.GenericRecord;
import org.apache.avro.reflect.ReflectData;
import org.apache.avro.reflect.ReflectDatumReader;
import org.apache.avro.reflect.ReflectDatumWriter;
import org.apache.avro.specific.SpecificDatumReader;
import org.apache.avro.specific.SpecificDatumWriter;
import org.apache.avro.specific.SpecificRecordBase;
import org.apache.avro.util.Utf8;
/**
* Performance tests for various low level operations of
* Avro encoding and decoding.
*/
public class Perf {
private static final int COUNT = 250000; // needs to be a multiple of 4
private static final int CYCLES = 800;
/**
* Use a fixed value seed for random number generation
* to allow for better cross-run comparisons.
*/
private static final long SEED = 19781210;
protected static Random newRandom() {
return new Random(SEED);
}
private static class TestDescriptor {
Class<? extends Test> test;
String param;
TestDescriptor(Class<? extends Test> test, String param) {
this.test = test;
this.param = param;
}
void add(List<TestDescriptor> typeList) {
ALL_TESTS.put(param, this);
typeList.add(this);
}
}
private static final List<TestDescriptor> BASIC = new ArrayList<TestDescriptor>();
private static final List<TestDescriptor> RECORD = new ArrayList<TestDescriptor>();
private static final List<TestDescriptor> GENERIC = new ArrayList<TestDescriptor>();
private static final List<TestDescriptor> GENERIC_ONETIME = new ArrayList<TestDescriptor>();
private static final List<TestDescriptor> SPECIFIC = new ArrayList<TestDescriptor>();
private static final List<TestDescriptor> REFLECT = new ArrayList<TestDescriptor>();
private static final LinkedHashMap<String, TestDescriptor> ALL_TESTS;
private static final LinkedHashMap<String, List<TestDescriptor>> BATCHES;
static {
ALL_TESTS = new LinkedHashMap<String, TestDescriptor>();
BATCHES = new LinkedHashMap<String, List<TestDescriptor>>();
BATCHES.put("-basic", BASIC);
new TestDescriptor(IntTest.class, "-i").add(BASIC);
new TestDescriptor(SmallLongTest.class, "-ls").add(BASIC);
new TestDescriptor(LongTest.class, "-l").add(BASIC);
new TestDescriptor(FloatTest.class, "-f").add(BASIC);
new TestDescriptor(DoubleTest.class, "-d").add(BASIC);
new TestDescriptor(BoolTest.class, "-b").add(BASIC);
new TestDescriptor(BytesTest.class, "-by").add(BASIC);
new TestDescriptor(StringTest.class, "-s").add(BASIC);
new TestDescriptor(ArrayTest.class, "-a").add(BASIC);
new TestDescriptor(MapTest.class, "-m").add(BASIC);
BATCHES.put("-record", RECORD);
new TestDescriptor(RecordTest.class, "-R").add(RECORD);
new TestDescriptor(ValidatingRecord.class, "-Rv").add(RECORD);
new TestDescriptor(ResolvingRecord.class, "-Rr").add(RECORD);
new TestDescriptor(RecordWithDefault.class, "-Rd").add(RECORD);
new TestDescriptor(RecordWithOutOfOrder.class, "-Ro").add(RECORD);
new TestDescriptor(RecordWithPromotion.class, "-Rp").add(RECORD);
BATCHES.put("-generic", GENERIC);
new TestDescriptor(GenericTest.class, "-G").add(GENERIC);
new TestDescriptor(GenericStrings.class, "-Gs").add(GENERIC);
new TestDescriptor(GenericNested.class, "-Gn").add(GENERIC);
new TestDescriptor(GenericNestedFake.class, "-Gf").add(GENERIC);
new TestDescriptor(GenericWithDefault.class, "-Gd").add(GENERIC);
new TestDescriptor(GenericWithOutOfOrder.class, "-Go").add(GENERIC);
new TestDescriptor(GenericWithPromotion.class, "-Gp").add(GENERIC);
BATCHES.put("-generic-onetime", GENERIC_ONETIME);
new TestDescriptor(GenericOneTimeDecoderUse.class, "-Gotd").add(GENERIC_ONETIME);
new TestDescriptor(GenericOneTimeReaderUse.class, "-Gotr").add(GENERIC_ONETIME);
new TestDescriptor(GenericOneTimeUse.class, "-Got").add(GENERIC_ONETIME);
new TestDescriptor(FooBarSpecificRecordTest.class, "-Sf").add(SPECIFIC);
BATCHES.put("-reflect", REFLECT);
new TestDescriptor(ReflectRecordTest.class, "-REFr").add(REFLECT);
new TestDescriptor(ReflectBigRecordTest.class, "-REFbr").add(REFLECT);
new TestDescriptor(ReflectFloatTest.class, "-REFf").add(REFLECT);
new TestDescriptor(ReflectDoubleTest.class, "-REFd").add(REFLECT);
new TestDescriptor(ReflectIntArrayTest.class, "-REFia").add(REFLECT);
new TestDescriptor(ReflectLongArrayTest.class, "-REFla").add(REFLECT);
new TestDescriptor(ReflectDoubleArrayTest.class, "-REFda").add(REFLECT);
new TestDescriptor(ReflectFloatArrayTest.class, "-REFfa").add(REFLECT);
new TestDescriptor(ReflectNestedFloatArrayTest.class, "-REFnf").add(REFLECT);
new TestDescriptor(ReflectNestedObjectArrayTest.class, "-REFno").add(REFLECT);
new TestDescriptor(ReflectNestedLargeFloatArrayTest.class, "-REFnlf").add(REFLECT);
new TestDescriptor(ReflectNestedLargeFloatArrayBlockedTest.class, "-REFnlfb").add(REFLECT);
}
private static void usage() {
StringBuilder usage = new StringBuilder("Usage: Perf { -nowrite | -noread | ");
StringBuilder details = new StringBuilder();
details.append(" -nowrite (do not execute write tests)\n");
details.append(" -noread (do not execute write tests)\n");
for (Map.Entry<String, List<TestDescriptor>> entry : BATCHES.entrySet()) {
List<TestDescriptor> lt = entry.getValue();
String param = entry.getKey();
String paramName = param.substring(1);
usage.append(param).append(" | ");
details.append(" ").append(param).append(" (executes all ").append(paramName).append(" tests):\n");
for (TestDescriptor t : lt) {
usage.append(t.param).append(" | ");
details.append(" ").append(t.param).append(" (").append(t.test.getSimpleName()).append(")\n");
}
}
usage.setLength(usage.length() - 2);
usage.append("}\n");
System.out.println(usage.toString());
System.out.print(details.toString());
}
public static void main(String[] args) throws Exception {
List<Test> tests = new ArrayList<Test>();
boolean writeTests = true;
boolean readTests = true;
for (String a : args) {
TestDescriptor t = ALL_TESTS.get(a);
if (null != t) {
tests.add(t.test.newInstance());
continue;
}
List<TestDescriptor> lt = BATCHES.get(a);
if (null != lt) {
for (TestDescriptor td : lt) {
tests.add(td.test.newInstance());
}
continue;
}
if ("-nowrite".equals(a)) {
writeTests = false;
continue;
}
if ("-noread".equals(a)) {
readTests = false;
continue;
}
usage();
System.exit(1);
}
if (tests.isEmpty()) {
for (Map.Entry<String, TestDescriptor> entry : ALL_TESTS.entrySet()) {
TestDescriptor t = entry.getValue();
Test test = t.test.newInstance();
tests.add(test);
}
}
System.out.println("Executing tests: \n" + tests + "\n readTests:" +
readTests + "\n writeTests:" + writeTests + "\n cycles=" + CYCLES);
for (int k = 0; k < tests.size(); k++) {
Test t = tests.get(k);
try {
// get everything to compile once
t.init();
if (t.isReadTest()) {
t.readTest();
}
if (t.isWriteTest()) {
t.writeTest();
}
t.reset();
} catch (Exception e) {
System.out.println("Failed to execute test: " + t.getClass().getSimpleName());
throw e;
}
}
printHeader();
for (int k = 0; k < tests.size(); k++) {
Test t = tests.get(k);
// warmup JVM
t.init();
if (t.isReadTest() && readTests) {
for (int i = 0; i < t.cycles/2; i++) {
t.readTest();
}
}
if (t.isWriteTest() && writeTests) {
for (int i = 0; i < t.cycles/2; i++) {
t.writeTest();
}
}
t.reset();
// test
long s = 0;
System.gc();
t.init();
if (t.isReadTest() && readTests) {
for (int i = 0; i < t.cycles; i++) {
s += t.readTest();
}
printResult(s, t, t.name + "Read");
}
s = 0;
if (t.isWriteTest() && writeTests) {
for (int i = 0; i < t.cycles; i++) {
s += t.writeTest();
}
printResult(s, t, t.name + "Write");
}
t.reset();
}
}
private static final void printHeader() {
String header = String.format(
"%60s time M entries/sec M bytes/sec bytes/cycle",
"test name");
System.out.println(header.toString());
}
private static final void printResult(long s, Test t, String name) {
s /= 1000;
double entries = (t.cycles * (double) t.count);
double bytes = t.cycles * (double) t.encodedSize;
StringBuilder result = new StringBuilder();
result.append(String.format("%42s: %6d ms ", name, (s/1000)));
result.append(String.format("%10.3f %11.3f %11d",
(entries / s), (bytes/ s), t.encodedSize));
System.out.println(result.toString());
}
private abstract static class Test {
/**
* Name of the test.
*/
public final String name;
public final int count;
public final int cycles;
public long encodedSize = 0;
protected boolean isReadTest = true;
protected boolean isWriteTest = true;
static DecoderFactory decoder_factory = new DecoderFactory();
static EncoderFactory encoder_factory = new EncoderFactory();
public Test(String name, int cycles, int count) {
this.name = name;
this.cycles = cycles;
this.count = count;
}
/**
* Reads data from a Decoder and returns the time taken in nanoseconds.
*/
abstract long readTest() throws IOException;
/**
* Writes data to an Encoder and returns the time taken in nanoseconds.
*/
abstract long writeTest() throws IOException;
final boolean isWriteTest() {
return isWriteTest;
}
final boolean isReadTest() {
return isReadTest;
}
/** initializes data for read and write tests **/
abstract void init() throws IOException;
/** clears generated data arrays and other large objects created during initialization **/
abstract void reset();
@Override
public String toString() {
return this.getClass().getSimpleName();
}
}
/** the basic test writes a simple schema directly to an encoder or
* reads from an array. It does not use GenericDatumReader or any
* higher level constructs, just manual serialization.
*/
private static abstract class BasicTest extends Test {
protected final Schema schema;
protected byte[] data;
BasicTest(String name, String json) throws IOException {
this(name, json, 1);
}
BasicTest(String name, String json, int factor) throws IOException {
super(name, CYCLES, COUNT/factor);
this.schema = new Schema.Parser().parse(json);
}
@Override
public final long readTest() throws IOException {
long t = System.nanoTime();
Decoder d = getDecoder();
readInternal(d);
return (System.nanoTime() - t);
}
@Override
public final long writeTest() throws IOException {
long t = System.nanoTime();
Encoder e = getEncoder();
writeInternal(e);
e.flush();
return (System.nanoTime() - t);
}
protected Decoder getDecoder() throws IOException {
return newDecoder();
}
private Encoder getEncoder() throws IOException {
return newEncoder(getOutputStream());
}
protected Decoder newDecoder() {
return decoder_factory.binaryDecoder(data, null);
}
protected Encoder newEncoder(ByteArrayOutputStream out) throws IOException {
Encoder e = encoder_factory.binaryEncoder(out, null);
// Encoder e = encoder_factory.directBinaryEncoder(out, null);
// Encoder e = encoder_factory.blockingBinaryEncoder(out, null);
// Encoder e = new LegacyBinaryEncoder(out);
return e;
}
private ByteArrayOutputStream getOutputStream() {
return new ByteArrayOutputStream((int)(encodedSize > 0 ? encodedSize : count));
}
@Override
void init() throws IOException {
genSourceData();
ByteArrayOutputStream baos = getOutputStream();
Encoder e = newEncoder(baos);
writeInternal(e);
e.flush();
data = baos.toByteArray();
encodedSize = data.length;
//System.out.println(this.getClass().getSimpleName() + " encodedSize=" + encodedSize);
}
abstract void genSourceData();
abstract void readInternal(Decoder d) throws IOException;
abstract void writeInternal(Encoder e) throws IOException;
}
static class IntTest extends BasicTest {
protected int[] sourceData = null;
public IntTest() throws IOException {
this("Int", "{ \"type\": \"int\"} ");
}
private IntTest(String name, String schema) throws IOException {
super(name, schema);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new int[count];
for (int i = 0; i < sourceData.length; i+=4) {
sourceData[i] = r.nextInt(50); // fits in 1 byte
sourceData[i+1] = r.nextInt(5000); // fits in 2 bytes
sourceData[i+2] = r.nextInt(500000); // fits in 3 bytes
sourceData[i+3] = r.nextInt(150000000); // most in 4, some in 5
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count/4; i++) {
d.readInt();
d.readInt();
d.readInt();
d.readInt();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length; i+=4) {
e.writeInt(sourceData[i]);
e.writeInt(sourceData[i+1]);
e.writeInt(sourceData[i+2]);
e.writeInt(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
// This is the same data as ReadInt, but using readLong.
static class SmallLongTest extends IntTest {
public SmallLongTest() throws IOException {
super("SmallLong", "{ \"type\": \"long\"} ");
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count/4; i++) {
d.readLong();
d.readLong();
d.readLong();
d.readLong();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length; i+=4) {
e.writeLong(sourceData[i]);
e.writeLong(sourceData[i+1]);
e.writeLong(sourceData[i+2]);
e.writeLong(sourceData[i+3]);
}
}
}
// this tests reading Longs that are sometimes very large
static class LongTest extends BasicTest {
private long[] sourceData = null;
public LongTest() throws IOException {
super("Long", "{ \"type\": \"long\"} ");
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new long[count];
for (int i = 0; i < sourceData.length; i+=4) {
sourceData[i] = r.nextLong() % 0x7FL; // half fit in 1, half in 2
sourceData[i+1] = r.nextLong() % 0x1FFFFFL; // half fit in <=3, half in 4
sourceData[i+2] = r.nextLong() % 0x3FFFFFFFFL; // half in <=5, half in 6
sourceData[i+3] = r.nextLong() % 0x1FFFFFFFFFFFFL; // half in <=8, half in 9
}
// last 16, make full size
for (int i = sourceData.length - 16; i < sourceData.length; i ++) {
sourceData[i] = r.nextLong();
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count/4; i++) {
d.readLong();
d.readLong();
d.readLong();
d.readLong();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length;i+=4) {
e.writeLong(sourceData[i]);
e.writeLong(sourceData[i+1]);
e.writeLong(sourceData[i+2]);
e.writeLong(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class FloatTest extends BasicTest {
float[] sourceData = null;
public FloatTest() throws IOException {
this("Float", "{ \"type\": \"float\"} ");
}
public FloatTest(String name, String schema) throws IOException {
super(name, schema);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new float[count];
for (int i = 0; i < sourceData.length;) {
sourceData[i++] = r.nextFloat();
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count; i+=4) {
d.readFloat();
d.readFloat();
d.readFloat();
d.readFloat();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length;i+=4) {
e.writeFloat(sourceData[i]);
e.writeFloat(sourceData[i+1]);
e.writeFloat(sourceData[i+2]);
e.writeFloat(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class DoubleTest extends BasicTest {
double[] sourceData = null;
public DoubleTest() throws IOException {
super("Double", "{ \"type\": \"double\"} ");
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new double[count];
for (int i = 0; i < sourceData.length;) {
sourceData[i++] = r.nextDouble();
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count; i+=4) {
d.readDouble();
d.readDouble();
d.readDouble();
d.readDouble();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length;i+=4) {
e.writeDouble(sourceData[i]);
e.writeDouble(sourceData[i+1]);
e.writeDouble(sourceData[i+2]);
e.writeDouble(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class BoolTest extends BasicTest {
boolean[] sourceData = null;
public BoolTest() throws IOException {
super("Boolean", "{ \"type\": \"boolean\"} ");
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new boolean[count];
for (int i = 0; i < sourceData.length;) {
sourceData[i++] = r.nextBoolean();
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count/4; i++) {
d.readBoolean();
d.readBoolean();
d.readBoolean();
d.readBoolean();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length;i+=4) {
e.writeBoolean(sourceData[i]);
e.writeBoolean(sourceData[i+1]);
e.writeBoolean(sourceData[i+2]);
e.writeBoolean(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class BytesTest extends BasicTest {
byte[][] sourceData = null;
public BytesTest() throws IOException {
super("Bytes", "{ \"type\": \"bytes\"} ", 5);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new byte[count][];
for (int i = 0; i < sourceData.length;) {
byte[] data = new byte[r.nextInt(70)];
r.nextBytes(data);
sourceData[i++] = data;
}
}
@Override
void readInternal(Decoder d) throws IOException {
ByteBuffer bb = ByteBuffer.allocate(70);
for (int i = 0; i < count/4; i++) {
d.readBytes(bb);
d.readBytes(bb);
d.readBytes(bb);
d.readBytes(bb);
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length;i+=4) {
e.writeBytes(sourceData[i]);
e.writeBytes(sourceData[i+1]);
e.writeBytes(sourceData[i+2]);
e.writeBytes(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
private static String randomString(Random r) {
char[] data = new char[r.nextInt(70)];
for (int j = 0; j < data.length; j++) {
data[j] = (char)('a' + r.nextInt('z'-'a'));
}
return new String(data);
}
static class StringTest extends BasicTest {
String[] sourceData = null;
public StringTest() throws IOException {
super("String", "{ \"type\": \"string\"} ", 5);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new String[count];
for (int i = 0; i < sourceData.length;)
sourceData[i++] = randomString(r);
}
@Override
void readInternal(Decoder d) throws IOException {
Utf8 utf = new Utf8();
for (int i = 0; i < count/4; i++) {
d.readString(utf).toString();
d.readString(utf).toString();
d.readString(utf).toString();
d.readString(utf).toString();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length;i+=4) {
e.writeString(sourceData[i]);
e.writeString(sourceData[i+1]);
e.writeString(sourceData[i+2]);
e.writeString(sourceData[i+3]);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class ArrayTest extends FloatTest {
public ArrayTest() throws IOException {
super("Array",
"{ \"type\": \"array\", \"items\": " +
" { \"type\": \"record\", \"name\":\"Foo\", \"fields\": " +
" [{\"name\":\"bar\", \"type\":" +
" {\"type\": \"array\", \"items\": " +
" { \"type\": \"record\", \"name\":\"Vals\", \"fields\": [" +
" {\"name\":\"f1\", \"type\":\"float\"}," +
" {\"name\":\"f2\", \"type\":\"float\"}," +
" {\"name\":\"f3\", \"type\":\"float\"}," +
" {\"name\":\"f4\", \"type\":\"float\"}]" +
" }" +
" }" +
" }]}}");
}
@Override
void readInternal(Decoder d) throws IOException {
d.readArrayStart();
for (long i = d.readArrayStart(); i != 0; i = d.arrayNext()) {
for (long j = 0; j < i; j++) {
d.readFloat();
d.readFloat();
d.readFloat();
d.readFloat();
}
}
d.arrayNext();
}
@Override
void writeInternal(Encoder e) throws IOException {
int items = sourceData.length/4;
e.writeArrayStart();
e.setItemCount(1);
e.startItem();
e.writeArrayStart();
e.setItemCount(items);
for (int i = 0; i < sourceData.length;i+=4) {
e.startItem();
e.writeFloat(sourceData[i]);
e.writeFloat(sourceData[i+1]);
e.writeFloat(sourceData[i+2]);
e.writeFloat(sourceData[i+3]);
}
e.writeArrayEnd();
e.writeArrayEnd();
}
}
static class MapTest extends FloatTest {
public MapTest() throws IOException {
super("Map", "{ \"type\": \"map\", \"values\": " +
" { \"type\": \"record\", \"name\":\"Vals\", \"fields\": [" +
" {\"name\":\"f1\", \"type\":\"float\"}," +
" {\"name\":\"f2\", \"type\":\"float\"}," +
" {\"name\":\"f3\", \"type\":\"float\"}," +
" {\"name\":\"f4\", \"type\":\"float\"}]" +
" }} ");
}
@Override
void readInternal(Decoder d) throws IOException {
Utf8 key = new Utf8();
for (long i = d.readMapStart(); i != 0; i = d.mapNext()) {
for (long j = 0; j < i; j++) {
key = d.readString(key);
d.readFloat();
d.readFloat();
d.readFloat();
d.readFloat();
}
}
}
@Override
void writeInternal(Encoder e) throws IOException {
int items = sourceData.length/4;
e.writeMapStart();
e.setItemCount(items);
Utf8 foo = new Utf8("foo");
for (int i = 0; i < sourceData.length;i+=4) {
e.startItem();
e.writeString(foo);
e.writeFloat(sourceData[i]);
e.writeFloat(sourceData[i+1]);
e.writeFloat(sourceData[i+2]);
e.writeFloat(sourceData[i+3]);
}
e.writeMapEnd();
}
}
private static final String RECORD_SCHEMA =
"{ \"type\": \"record\", \"name\": \"R\", \"fields\": [\n"
+ "{ \"name\": \"f1\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f2\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f3\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f4\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f5\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f6\", \"type\": \"int\" }\n"
+ "] }";
private static final String NESTED_RECORD_SCHEMA =
"{ \"type\": \"record\", \"name\": \"R\", \"fields\": [\n"
+ "{ \"name\": \"f1\", \"type\": \n" +
"{ \"type\": \"record\", \"name\": \"D\", \"fields\": [\n" +
"{\"name\": \"dbl\", \"type\": \"double\" }]\n" +
"} },\n"
+ "{ \"name\": \"f2\", \"type\": \"D\" },\n"
+ "{ \"name\": \"f3\", \"type\": \"D\" },\n"
+ "{ \"name\": \"f4\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f5\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f6\", \"type\": \"int\" }\n"
+ "] }";
private static class Rec {
double f1;
double f2;
double f3;
int f4;
int f5;
int f6;
Rec() {
}
Rec(Random r) {
f1 = r.nextDouble();
f2 = r.nextDouble();
f3 = r.nextDouble();
f4 = r.nextInt();
f5 = r.nextInt();
f6 = r.nextInt();
}
}
static class RecordTest extends BasicTest {
Rec[] sourceData = null;
public RecordTest() throws IOException {
this("Record");
}
public RecordTest(String name) throws IOException {
super(name, RECORD_SCHEMA, 6);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new Rec[count];
for (int i = 0; i < sourceData.length; i++) {
sourceData[i] = new Rec(r);
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count; i++) {
d.readDouble();
d.readDouble();
d.readDouble();
d.readInt();
d.readInt();
d.readInt();
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length; i++) {
Rec r = sourceData[i];
e.writeDouble(r.f1);
e.writeDouble(r.f2);
e.writeDouble(r.f3);
e.writeInt(r.f4);
e.writeInt(r.f5);
e.writeInt(r.f6);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class ValidatingRecord extends RecordTest {
ValidatingRecord() throws IOException {
super("ValidatingRecord");
}
@Override
protected Decoder getDecoder() throws IOException {
return new ValidatingDecoder(schema, super.getDecoder());
}
@Override
protected Encoder newEncoder(ByteArrayOutputStream out) throws IOException {
return encoder_factory.validatingEncoder(schema, super.newEncoder(out));
}
}
static class ResolvingRecord extends RecordTest {
public ResolvingRecord() throws IOException {
super("ResolvingRecord");
isWriteTest = false;
}
@Override
protected Decoder getDecoder() throws IOException {
return new ResolvingDecoder(schema, schema, super.getDecoder());
}
}
private static final String RECORD_SCHEMA_WITH_DEFAULT =
"{ \"type\": \"record\", \"name\": \"R\", \"fields\": [\n"
+ "{ \"name\": \"f1\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f2\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f3\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f4\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f5\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f6\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f7\", \"type\": \"string\", "
+ "\"default\": \"undefined\" },\n"
+ "{ \"name\": \"f8\", \"type\": \"string\","
+ "\"default\": \"undefined\" }\n"
+ "] }";
private static final String RECORD_SCHEMA_WITH_OUT_OF_ORDER =
"{ \"type\": \"record\", \"name\": \"R\", \"fields\": [\n"
+ "{ \"name\": \"f1\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f3\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f5\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f2\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f4\", \"type\": \"int\" },\n"
+ "{ \"name\": \"f6\", \"type\": \"int\" }\n"
+ "] }";
private static final String RECORD_SCHEMA_WITH_PROMOTION =
"{ \"type\": \"record\", \"name\": \"R\", \"fields\": [\n"
+ "{ \"name\": \"f1\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f2\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f3\", \"type\": \"double\" },\n"
+ "{ \"name\": \"f4\", \"type\": \"long\" },\n"
+ "{ \"name\": \"f5\", \"type\": \"long\" },\n"
+ "{ \"name\": \"f6\", \"type\": \"long\" }\n"
+ "] }";
/**
* Tests the performance of introducing default values.
*/
static class RecordWithDefault extends RecordTest {
private final Schema readerSchema;
public RecordWithDefault() throws IOException {
super("RecordWithDefault");
readerSchema = new Schema.Parser().parse(RECORD_SCHEMA_WITH_DEFAULT);
isWriteTest = false;
}
@Override
protected Decoder getDecoder() throws IOException {
return new ResolvingDecoder(schema, readerSchema, super.getDecoder());
}
@Override
protected void readInternal(Decoder d) throws IOException {
ResolvingDecoder r = (ResolvingDecoder) d;
Field[] ff = r.readFieldOrder();
for (int i = 0; i < count; i++) {
for (int j = 0; j < ff.length; j++) {
Field f = ff[j];
switch (f.pos()) {
case 0:
case 1:
case 2:
r.readDouble();
break;
case 3:
case 4:
case 5:
r.readInt();
break;
case 6:
case 7:
r.readString(null);
break;
}
}
}
}
}
/**
* Tests the performance of resolving a change in field order.
*/
static class RecordWithOutOfOrder extends RecordTest {
private final Schema readerSchema;
public RecordWithOutOfOrder() throws IOException {
super("RecordWithOutOfOrder");
readerSchema = new Schema.Parser().parse(RECORD_SCHEMA_WITH_OUT_OF_ORDER);
isWriteTest = false;
}
@Override
protected Decoder getDecoder() throws IOException {
return new ResolvingDecoder(schema, readerSchema, super.getDecoder());
}
@Override
protected void readInternal(Decoder d) throws IOException {
ResolvingDecoder r = (ResolvingDecoder) d;
Field[] ff = r.readFieldOrder();
for (int i = 0; i < count; i++) {
for (int j = 0; j < ff.length; j++) {
Field f = ff[j];
switch (f.pos()) {
case 0:
case 1:
case 3:
r.readDouble();
break;
case 2:
case 4:
case 5:
r.readInt();
break;
}
}
}
}
}
/**
* Tests the performance of resolving a type promotion.
*/
static class RecordWithPromotion extends RecordTest {
private final Schema readerSchema;
public RecordWithPromotion() throws IOException {
super("RecordWithPromotion");
readerSchema = new Schema.Parser().parse(RECORD_SCHEMA_WITH_PROMOTION);
isWriteTest = false;
}
@Override
protected Decoder getDecoder() throws IOException {
return new ResolvingDecoder(schema, readerSchema, super.getDecoder());
}
@Override
protected void readInternal(Decoder d) throws IOException {
ResolvingDecoder r = (ResolvingDecoder) d;
Field[] ff = r.readFieldOrder();
for (int i = 0; i < count; i++) {
for (int j = 0; j < ff.length; j++) {
Field f = ff[j];
switch (f.pos()) {
case 0:
case 1:
case 2:
r.readDouble();
break;
case 3:
case 4:
case 5:
r.readLong();
break;
}
}
}
}
}
static class GenericTest extends BasicTest {
GenericRecord[] sourceData = null;
protected final GenericDatumReader<Object> reader;
public GenericTest() throws IOException {
this("Generic");
}
protected GenericTest(String name) throws IOException {
this(name, RECORD_SCHEMA);
}
protected GenericTest(String name, String writerSchema) throws IOException {
super(name, writerSchema, 12);
reader = newReader();
}
protected GenericDatumReader<Object> getReader() {
return reader;
}
protected GenericDatumReader<Object> newReader() {
return new GenericDatumReader<Object>(schema);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new GenericRecord[count];
for (int i = 0; i < sourceData.length; i++) {
GenericRecord rec = new GenericData.Record(schema);
rec.put(0, r.nextDouble());
rec.put(1, r.nextDouble());
rec.put(2, r.nextDouble());
rec.put(3, r.nextInt());
rec.put(4, r.nextInt());
rec.put(5, r.nextInt());
sourceData[i] = rec;
}
}
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count; i++) {
getReader().read(null, d);
}
}
@Override
void writeInternal(Encoder e) throws IOException {
GenericDatumWriter<Object> writer = new GenericDatumWriter<Object>(schema);
for (int i = 0; i < sourceData.length; i++) {
GenericRecord rec = sourceData[i];
writer.write(rec, e);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
private static final String GENERIC_STRINGS =
"{ \"type\": \"record\", \"name\": \"R\", \"fields\": [\n"
+ "{ \"name\": \"f1\", \"type\": \"string\" },\n"
+ "{ \"name\": \"f2\", \"type\": \"string\" },\n"
+ "{ \"name\": \"f3\", \"type\": \"string\" }\n"
+ "] }";
static class GenericStrings extends GenericTest {
public GenericStrings() throws IOException {
super("GenericStrings", GENERIC_STRINGS);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new GenericRecord[count];
for (int i = 0; i < sourceData.length; i++) {
GenericRecord rec = new GenericData.Record(schema);
rec.put(0, randomString(r));
rec.put(1, randomString(r));
rec.put(2, randomString(r));
sourceData[i] = rec;
}
}
}
static class GenericNested extends GenericTest {
public GenericNested() throws IOException {
super("GenericNested_", NESTED_RECORD_SCHEMA);
}
@Override
void genSourceData() {
sourceData = generateGenericNested(schema, count);
}
}
static GenericRecord[] generateGenericNested(Schema schema, int count) {
Random r = newRandom();
GenericRecord[] sourceData = new GenericRecord[count];
Schema doubleSchema = schema.getFields().get(0).schema();
for (int i = 0; i < sourceData.length; i++) {
GenericRecord rec = new GenericData.Record(schema);
GenericRecord inner;
inner = new GenericData.Record(doubleSchema);
inner.put(0, r.nextDouble());
rec.put(0, inner);
inner = new GenericData.Record(doubleSchema);
inner.put(0, r.nextDouble());
rec.put(1, inner);
inner = new GenericData.Record(doubleSchema);
inner.put(0, r.nextDouble());
rec.put(2, inner);
rec.put(3, r.nextInt());
rec.put(4, r.nextInt());
rec.put(5, r.nextInt());
sourceData[i] = rec;
}
return sourceData;
}
static class GenericNestedFake extends BasicTest {
//reads and writes generic data, but not using
//GenericDatumReader or GenericDatumWriter
GenericRecord[] sourceData = null;
public GenericNestedFake() throws IOException {
super("GenericNestedFake_", NESTED_RECORD_SCHEMA, 12);
}
@Override
void readInternal(Decoder d) throws IOException {
Schema doubleSchema = schema.getFields().get(0).schema();
for (int i = 0; i < count; i++) {
GenericRecord rec = new GenericData.Record(schema);
GenericRecord inner;
inner = new GenericData.Record(doubleSchema);
inner.put(0, d.readDouble());
rec.put(0, inner);
inner = new GenericData.Record(doubleSchema);
inner.put(0, d.readDouble());
rec.put(1, inner);
inner = new GenericData.Record(doubleSchema);
inner.put(0, d.readDouble());
rec.put(2, inner);
rec.put(3, d.readInt());
rec.put(4, d.readInt());
rec.put(5, d.readInt());
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length; i++) {
GenericRecord rec = sourceData[i];
GenericRecord inner;
inner = (GenericRecord)rec.get(0);
e.writeDouble((Double)inner.get(0));
inner = (GenericRecord)rec.get(1);
e.writeDouble((Double)inner.get(0));
inner = (GenericRecord)rec.get(2);
e.writeDouble((Double)inner.get(0));
e.writeInt((Integer)rec.get(3));
e.writeInt((Integer)rec.get(4));
e.writeInt((Integer)rec.get(5));
}
}
@Override
void genSourceData() {
sourceData = generateGenericNested(schema, count);
}
@Override
void reset() {
data = null;
sourceData = null;
}
}
private static abstract class GenericResolving extends GenericTest {
protected GenericResolving(String name)
throws IOException {
super(name);
isWriteTest = false;
}
@Override
protected GenericDatumReader<Object> newReader() {
return new GenericDatumReader<Object>(schema, getReaderSchema());
}
protected abstract Schema getReaderSchema();
}
static class GenericWithDefault extends GenericResolving {
GenericWithDefault() throws IOException {
super("GenericWithDefault_");
}
@Override
protected Schema getReaderSchema() {
return new Schema.Parser().parse(RECORD_SCHEMA_WITH_DEFAULT);
}
}
static class GenericWithOutOfOrder extends GenericResolving {
GenericWithOutOfOrder() throws IOException {
super("GenericWithOutOfOrder_");
}
@Override
protected Schema getReaderSchema() {
return new Schema.Parser().parse(RECORD_SCHEMA_WITH_OUT_OF_ORDER);
}
}
static class GenericWithPromotion extends GenericResolving {
GenericWithPromotion() throws IOException {
super("GenericWithPromotion_");
}
@Override
protected Schema getReaderSchema() {
return new Schema.Parser().parse(RECORD_SCHEMA_WITH_PROMOTION);
}
}
static class GenericOneTimeDecoderUse extends GenericTest {
public GenericOneTimeDecoderUse() throws IOException {
super("GenericOneTimeDecoderUse_");
isWriteTest = false;
}
@Override
protected Decoder getDecoder() {
return newDecoder();
}
}
static class GenericOneTimeReaderUse extends GenericTest {
public GenericOneTimeReaderUse() throws IOException {
super("GenericOneTimeReaderUse_");
isWriteTest = false;
}
@Override
protected GenericDatumReader<Object> getReader() {
return newReader();
}
}
static class GenericOneTimeUse extends GenericTest {
public GenericOneTimeUse() throws IOException {
super("GenericOneTimeUse_");
isWriteTest = false;
}
@Override
protected GenericDatumReader<Object> getReader() {
return newReader();
}
@Override
protected Decoder getDecoder() {
return newDecoder();
}
}
static abstract class SpecificTest<T extends SpecificRecordBase> extends BasicTest {
protected final SpecificDatumReader<T> reader;
protected final SpecificDatumWriter<T> writer;
private Object[] sourceData;
protected SpecificTest(String name, String writerSchema) throws IOException {
super(name, writerSchema, 48);
reader = newReader();
writer = newWriter();
}
protected SpecificDatumReader<T> getReader() {
return reader;
}
protected SpecificDatumWriter<T> getWriter() {
return writer;
}
protected SpecificDatumReader<T> newReader() {
return new SpecificDatumReader<T>(schema);
}
protected SpecificDatumWriter<T> newWriter() {
return new SpecificDatumWriter<T>(schema);
}
@Override
void genSourceData() {
Random r = newRandom();
sourceData = new Object[count];
for (int i = 0; i < sourceData.length; i++) {
sourceData[i] = genSingleRecord(r);
}
}
protected abstract T genSingleRecord(Random r);
@Override
void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count; i++) {
getReader().read(null, d);
}
}
@Override
void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length; i++) {
@SuppressWarnings("unchecked")
T rec = (T) sourceData[i];
getWriter().write(rec, e);
}
}
@Override
void reset() {
sourceData = null;
data = null;
}
}
static class FooBarSpecificRecordTest extends
SpecificTest<FooBarSpecificRecord> {
public FooBarSpecificRecordTest() throws IOException {
super("FooBarSpecificRecordTest", FooBarSpecificRecord.SCHEMA$.toString());
}
@Override
protected FooBarSpecificRecord genSingleRecord(Random r) {
TypeEnum[] typeEnums = TypeEnum.values();
List<Integer> relatedIds = new ArrayList<Integer>(10);
for (int i = 0; i < 10; i++) {
relatedIds.add(r.nextInt());
}
try {
return FooBarSpecificRecord.newBuilder().setId(r.nextInt())
.setName(randomString(r))
.setNicknames(Arrays.asList(randomString(r), randomString(r)))
.setTypeEnum(typeEnums[r.nextInt(typeEnums.length)])
.setRelatedids(relatedIds).build();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
static abstract class ReflectTest<T> extends BasicTest {
T[] sourceData = null;
ReflectDatumReader<T> reader;
ReflectDatumWriter<T> writer;
Class<T> clazz;
@SuppressWarnings("unchecked")
ReflectTest(String name, T sample, int factor) throws IOException {
super(name, ReflectData.get().getSchema(sample.getClass()).toString(), factor);
clazz = (Class<T>) sample.getClass();
reader = new ReflectDatumReader<T>(schema);
writer = new ReflectDatumWriter<T>(schema);
}
@SuppressWarnings("unchecked")
@Override
protected final void genSourceData() {
Random r = newRandom();
sourceData = (T[]) Array.newInstance(clazz, count);
for (int i = 0; i < sourceData.length; i++) {
sourceData[i] = createDatum(r);
}
}
protected abstract T createDatum(Random r);
@Override
protected final void readInternal(Decoder d) throws IOException {
for (int i = 0; i < count; i++) {
reader.read(null, d);
}
}
@Override
protected final void writeInternal(Encoder e) throws IOException {
for (int i = 0; i < sourceData.length; i++) {
writer.write(sourceData[i], e);
}
}
@Override
protected final void reset() {
sourceData = null;
data = null;
}
}
static class ReflectRecordTest extends ReflectTest<Rec> {
ReflectRecordTest() throws IOException {
super("ReflectRecord", new Rec(), 12);
}
@Override
protected Rec createDatum(Random r) {
return new Rec(r);
}
}
static class ReflectFloatTest extends ReflectTest<float[]> {
ReflectFloatTest() throws IOException {
super("ReflectFloat", new float[0], COUNT);
}
@Override
protected float[] createDatum(Random r) {
return populateFloatArray(r, COUNT / count);
}
}
static class ReflectDoubleTest extends ReflectTest<double[]> {
ReflectDoubleTest() throws IOException {
super("ReflectDouble", new double[0], COUNT);
}
@Override
protected double[] createDatum(Random r) {
return populateDoubleArray(r, COUNT / count);
}
}
static class ReflectFloatArrayTest extends ReflectTest<float[]> {
ReflectFloatArrayTest() throws IOException {
super("ReflectFloatArray", new float[0], 10);
}
@Override
protected float[] createDatum(Random r) {
return populateFloatArray(r, false);
}
}
static class ReflectDoubleArrayTest extends ReflectTest<double[]> {
ReflectDoubleArrayTest() throws IOException {
super("ReflectDoubleArray", new double[0], 20);
}
@Override
protected double[] createDatum(Random r) {
return populateDoubleArray(r);
}
}
static class ReflectIntArrayTest extends ReflectTest<int[]> {
ReflectIntArrayTest() throws IOException {
super("ReflectIntArray", new int[0], 12);
}
@Override
protected int[] createDatum(Random r) {
return populateIntArray(r);
}
}
static class ReflectLongArrayTest extends ReflectTest<long[]> {
ReflectLongArrayTest() throws IOException {
super("ReflectLongArray", new long[0], 24);
}
@Override
protected long[] createDatum(Random r) {
return populateLongArray(r);
}
}
static class ReflectNestedObjectArrayTest extends
ReflectTest<ReflectNestedObjectArrayTest.Foo> {
ReflectNestedObjectArrayTest() throws IOException {
super("ReflectNestedObjectArray", new Foo(new Random()), 50);
}
@Override
protected Foo createDatum(Random r) {
return new Foo(r);
}
static public class Foo {
Vals[] bar;
Foo() {
}
Foo(Random r) {
bar = new Vals[smallArraySize(r)];
for (int i = 0; i < bar.length; i++) {
bar[i] = new Vals(r);
}
}
}
static class Vals {
float f1;
float f2;
float f3;
float f4;
Vals(){
}
Vals(Random r) {
this.f1 = r.nextFloat();
this.f2 = r.nextFloat();
this.f3 = r.nextFloat();
this.f4 = r.nextFloat();
}
}
}
static public class FloatFoo {
float[] floatBar;
FloatFoo() {
}
FloatFoo(Random r, boolean large) {
floatBar = populateFloatArray(r, large);
}
}
// average of 8, between 1 and 15
private static int smallArraySize(Random r) {
return r.nextInt(15) + 1;
}
// average of 64, between 16 and 112
private static int largeArraySize(Random r) {
return r.nextInt(97) + 16;
}
static float[] populateFloatArray(Random r, boolean large) {
int size = large ? largeArraySize(r) : smallArraySize(r);
return populateFloatArray(r, size);
}
static float[] populateFloatArray(Random r, int size) {
float[] result = new float[size];
for (int i = 0; i < result.length; i++) {
result[i] = r.nextFloat();
}
return result;
}
static double[] populateDoubleArray(Random r) {
return populateDoubleArray(r, smallArraySize(r));
}
static double[] populateDoubleArray(Random r, int size) {
double[] result = new double[size];
for (int i = 0; i < result.length; i++) {
result[i] = r.nextDouble();
}
return result;
}
static int[] populateIntArray(Random r) {
int size = smallArraySize(r);
int[] result = new int[size];
for (int i = 0; i < result.length; i++) {
result[i] = r.nextInt();
}
return result;
}
static long[] populateLongArray(Random r) {
int size = smallArraySize(r);
long[] result = new long[size];
for (int i = 0; i < result.length; i++) {
result[i] = r.nextLong();
}
return result;
}
static class ReflectNestedFloatArrayTest extends ReflectTest<FloatFoo> {
public ReflectNestedFloatArrayTest() throws IOException {
super("ReflectNestedFloatArray", new FloatFoo(new Random(), false), 10);
}
@Override
protected FloatFoo createDatum(Random r) {
return new FloatFoo(r, false);
}
}
static class ReflectNestedLargeFloatArrayTest extends ReflectTest<FloatFoo> {
public ReflectNestedLargeFloatArrayTest() throws IOException {
super("ReflectNestedLargeFloatArray", new FloatFoo(new Random(), true),
60);
}
@Override
protected FloatFoo createDatum(Random r) {
return new FloatFoo(r, true);
}
}
static class ReflectNestedLargeFloatArrayBlockedTest extends ReflectTest<FloatFoo> {
public ReflectNestedLargeFloatArrayBlockedTest() throws IOException {
super("ReflectNestedLargeFloatArrayBlocked", new FloatFoo(new Random(), true),
60);
}
@Override
protected FloatFoo createDatum(Random r) {
return new FloatFoo(r, true);
}
@Override
protected Encoder newEncoder(ByteArrayOutputStream out) throws IOException {
return new EncoderFactory().configureBlockSize(254).blockingBinaryEncoder(out, null);
}
}
@SuppressWarnings("unused")
private static class Rec1 {
double d1;
double d11;
float f2;
float f22;
int f3;
int f33;
long f4;
long f44;
byte f5;
byte f55;
short f6;
short f66;
Rec1() {
}
Rec1(Random r) {
d1 = r.nextDouble();
d11 = r.nextDouble();
f2 = r.nextFloat();
f22 = r.nextFloat();
f3 = r.nextInt();
f33 = r.nextInt();
f4 = r.nextLong();
f44 = r.nextLong();
f5 = (byte) r.nextInt();
f55 = (byte) r.nextInt();
f6 = (short) r.nextInt();
f66 = (short) r.nextInt();
}
}
static class ReflectBigRecordTest extends ReflectTest<Rec1> {
public ReflectBigRecordTest() throws IOException {
super("ReflectBigRecord", new Rec1(new Random()), 20);
}
@Override
protected Rec1 createDatum(Random r) {
return new Rec1(r);
}
}
}