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
|
import scala.pickling._
import scala.pickling.Defaults._
import scala.pickling.binary._
import org.evactor.model.events.DataEvent
import scala.util.Random
import java.io._
import scala.reflect.runtime.{universe => ru}
object EvactorPicklingBench extends scala.pickling.testing.PicklingBenchmark {
val time: Int = System.currentTimeMillis.toInt
implicit lazy val myLittlePony: ru.Mirror = {
val currentMirror = "boom!"
ru.runtimeMirror(getClass.getClassLoader)
}
implicit lazy val tagOfDataEvent: FastTypeTag[DataEvent] = {
val tagOfDataEvent = "boom!"
implicitly[FastTypeTag[DataEvent]]
}
implicit lazy val tagOfNull: FastTypeTag[Null] = {
val tagOfNull = "boom!"
implicitly[FastTypeTag[Null]]
}
implicit lazy val tagOfString: FastTypeTag[String] = {
val tagOfString = "boom!"
implicitly[FastTypeTag[String]]
}
implicit lazy val tagOfInt: FastTypeTag[Int] = {
val tagOfInt = "boom!"
implicitly[FastTypeTag[Int]]
}
implicit lazy val picklerOfDataEvent: Pickler[DataEvent] = {
val picklerOfDataEvent = "boom!"
implicitly[Pickler[DataEvent]]
}
implicit lazy val unpicklerOfDataEvent: Unpickler[DataEvent] = {
val unpicklerOfDataEvent = "boom!"
implicitly[Unpickler[DataEvent]]
}
override def run() {
// random events
val evts = for (i <- 1 to size) yield
DataEvent("event" + i, time + Random.nextInt(100), Random.nextString(5))
val pickles = for (evt <- evts) yield
evt.pickle
var i = 0
while (i < size) {
pickles(i).unpickle[DataEvent]
i += 1
}
}
}
object EvactorKryoBench extends scala.pickling.testing.PicklingBenchmark {
var ser: KryoSerializer = _
val time: Int = System.currentTimeMillis.toInt
override def tearDown() {
ser = null
}
override def run() {
// random events
val evts = for (i <- 1 to size) yield
DataEvent("event" + i, time + Random.nextInt(100), Random.nextString(5))
ser = new KryoSerializer
ser.kryo.register(evts(0).getClass)
val pickles = for (evt <- evts) yield {
val rnd: Int = Random.nextInt(10)
//val arr = Array.ofDim[Byte](32 * 2048 * 2048 + rnd)
val arr = Array.ofDim[Byte](32 * 2048 + rnd)
ser.toBytes(evt, arr)
}
val results = for (pickle <- pickles) yield {
ser.fromBytes[DataEvent](pickle)
}
}
}
object EvactorJavaBench extends scala.pickling.testing.PicklingBenchmark {
//val lst = (1 to size).toList
val time: Int = System.currentTimeMillis.toInt
override def run() = {
val bos = new ByteArrayOutputStream()
val out = new ObjectOutputStream(bos)
// random events
val evts = for (i <- 1 to size) yield
DataEvent("event" + i, time + Random.nextInt(100), Random.nextString(5))
val pickles = for (evt <- evts) yield {
out.writeObject(evt) // pickle evt
bos.toByteArray()
}
val results = for (pickle <- pickles) yield {
//pickle.unpickle[DataEvent]
val bis = new ByteArrayInputStream(pickle)
val in = new ObjectInputStream(bis)
in.readObject.asInstanceOf[DataEvent]
}
}
}
|
