1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
/*
* Copyright (C) 2010 Google Inc.
*
* Licensed 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 benchmarks.regression;
import com.google.caliper.Param;
import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
public class SerializationBenchmark extends SimpleBenchmark {
private static byte[] bytes(Object o) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
ObjectOutputStream out = new ObjectOutputStream(baos);
out.writeObject(o);
out.close();
return baos.toByteArray();
}
public void timeReadIntArray(int reps) throws Exception {
int[] intArray = new int[256];
readSingleObject(reps, intArray);
}
public void timeWriteIntArray(int reps) throws Exception {
int[] intArray = new int[256];
writeSingleObject(reps, intArray);
}
public void timeReadArrayListInteger(int reps) throws Exception {
ArrayList<Integer> object = new ArrayList<Integer>();
for (int i = 0; i < 256; ++i) {
object.add(i);
}
readSingleObject(reps, object);
}
public void timeWriteArrayListInteger(int reps) throws Exception {
ArrayList<Integer> object = new ArrayList<Integer>();
for (int i = 0; i < 256; ++i) {
object.add(i);
}
writeSingleObject(reps, object);
}
public void timeReadString(int reps) throws Exception {
readSingleObject(reps, "hello");
}
public void timeReadObjectStreamClass(int reps) throws Exception {
// A special case because serialization itself requires this class.
// (This should really be a unit test.)
ObjectStreamClass osc = ObjectStreamClass.lookup(String.class);
readSingleObject(reps, osc);
}
public void timeWriteString(int reps) throws Exception {
// String is a special case that avoids JNI.
writeSingleObject(reps, "hello");
}
public void timeWriteObjectStreamClass(int reps) throws Exception {
// A special case because serialization itself requires this class.
// (This should really be a unit test.)
ObjectStreamClass osc = ObjectStreamClass.lookup(String.class);
writeSingleObject(reps, osc);
}
// This is a baseline for the others.
public void timeWriteNoObjects(int reps) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
ObjectOutputStream out = new ObjectOutputStream(baos);
for (int rep = 0; rep < reps; ++rep) {
out.reset();
baos.reset();
}
out.close();
}
private void readSingleObject(int reps, Object object) throws Exception {
byte[] bytes = bytes(object);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
for (int rep = 0; rep < reps; ++rep) {
ObjectInputStream in = new ObjectInputStream(bais);
in.readObject();
in.close();
bais.reset();
}
}
private void writeSingleObject(int reps, Object o) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
ObjectOutputStream out = new ObjectOutputStream(baos);
for (int rep = 0; rep < reps; ++rep) {
out.writeObject(o);
out.reset();
baos.reset();
}
out.close();
}
public void timeWriteEveryKindOfField(int reps) throws Exception {
writeSingleObject(reps, new LittleBitOfEverything());
}
public void timeWriteSerializableBoolean(int reps) throws Exception {
writeSingleObject(reps, new SerializableBoolean());
}
public void timeWriteSerializableByte(int reps) throws Exception {
writeSingleObject(reps, new SerializableByte());
}
public void timeWriteSerializableChar(int reps) throws Exception {
writeSingleObject(reps, new SerializableChar());
}
public void timeWriteSerializableDouble(int reps) throws Exception {
writeSingleObject(reps, new SerializableDouble());
}
public void timeWriteSerializableFloat(int reps) throws Exception {
writeSingleObject(reps, new SerializableFloat());
}
public void timeWriteSerializableInt(int reps) throws Exception {
writeSingleObject(reps, new SerializableInt());
}
public void timeWriteSerializableLong(int reps) throws Exception {
writeSingleObject(reps, new SerializableLong());
}
public void timeWriteSerializableShort(int reps) throws Exception {
writeSingleObject(reps, new SerializableShort());
}
public void timeWriteSerializableReference(int reps) throws Exception {
writeSingleObject(reps, new SerializableReference());
}
public void timeReadEveryKindOfField(int reps) throws Exception {
readSingleObject(reps, new LittleBitOfEverything());
}
public void timeReadSerializableBoolean(int reps) throws Exception {
readSingleObject(reps, new SerializableBoolean());
}
public void timeReadSerializableByte(int reps) throws Exception {
readSingleObject(reps, new SerializableByte());
}
public void timeReadSerializableChar(int reps) throws Exception {
readSingleObject(reps, new SerializableChar());
}
public void timeReadSerializableDouble(int reps) throws Exception {
readSingleObject(reps, new SerializableDouble());
}
public void timeReadSerializableFloat(int reps) throws Exception {
readSingleObject(reps, new SerializableFloat());
}
public void timeReadSerializableInt(int reps) throws Exception {
readSingleObject(reps, new SerializableInt());
}
public void timeReadSerializableLong(int reps) throws Exception {
readSingleObject(reps, new SerializableLong());
}
public void timeReadSerializableShort(int reps) throws Exception {
readSingleObject(reps, new SerializableShort());
}
public void timeReadSerializableReference(int reps) throws Exception {
readSingleObject(reps, new SerializableReference());
}
public static class SerializableBoolean implements Serializable {
boolean z;
}
public static class SerializableByte implements Serializable {
byte b;
}
public static class SerializableChar implements Serializable {
char c;
}
public static class SerializableDouble implements Serializable {
double d;
}
public static class SerializableFloat implements Serializable {
float f;
}
public static class SerializableInt implements Serializable {
int i;
}
public static class SerializableLong implements Serializable {
long j;
}
public static class SerializableShort implements Serializable {
short s;
}
public static class SerializableReference implements Serializable {
Object l;
}
public static class LittleBitOfEverything implements Serializable {
boolean z;
byte b;
char c;
double d;
float f;
int i;
long j;
short s;
Object l;
}
}
|
