Skip to content

Commit a46d5f8

Browse files
retronymretronym
committed
Vector.scala and scalap benchmarks
1 parent 25826a5 commit a46d5f8

26 files changed

+4383
-1
lines changed

‎src/main/java/scala/tools/nsc/benchmark/FlightRecordingProfiler.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,7 @@ public void beforeTrial(BenchmarkParams benchmarkParams) {
8181

8282
@Override
8383
public Collection<? extends Result> afterTrial(BenchmarkResult benchmarkResult, long l, File stdOut, File stdErr) {
84-
String target = SAVE_FLIGHT_OUTPUT_TO + "/" + benchmarkResult.getParams().id() + "-" + currentId++ + ".jfr";
84+
String target = SAVE_FLIGHT_OUTPUT_TO + "/" + benchmarkResult.getParams().id().replaceAll("/", "-") + "-" + currentId++ + ".jfr";
8585

8686
StringWriter sw = new StringWriter();
8787
PrintWriter pw = new PrintWriter(sw);

‎src/main/resources/scalap/Arguments.scala

Lines changed: 167 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,167 @@
1+
/* ___ ____ ___ __ ___ ___
2+
** / _// __// _ | / / / _ | / _ \ Scala classfile decoder
3+
** __\ \/ /__/ __ |/ /__/ __ |/ ___/ (c) 2003-2013, LAMP/EPFL
4+
** /____/\___/_/ |_/____/_/ |_/_/ http://scala-lang.org/
5+
**
6+
*/
7+
8+
9+
package scala.tools.scalap
10+
11+
import scala.collection.mutable
12+
import mutable.ListBuffer
13+
14+
object Arguments {
15+
case class Parser(optionPrefix: Char) {
16+
val options: mutable.Set[String] = new mutable.HashSet
17+
val prefixes: mutable.Set[String] = new mutable.HashSet
18+
val optionalArgs: mutable.Set[String] = new mutable.HashSet
19+
val prefixedBindings: mutable.Map[String, Char] = new mutable.HashMap
20+
val optionalBindings: mutable.Map[String, Char] = new mutable.HashMap
21+
22+
def argumentError(message: String): Unit = Console.println(message)
23+
24+
def withOption(option: String): Parser = {
25+
options += option
26+
this
27+
}
28+
29+
def withOptionalArg(option: String): Parser = {
30+
optionalArgs += option
31+
this
32+
}
33+
34+
def withOptionalBinding(option: String, separator: Char): Parser = {
35+
optionalBindings(option) = separator
36+
this
37+
}
38+
39+
def withPrefixedArg(prefix: String): Parser = {
40+
prefixes += prefix
41+
this
42+
}
43+
44+
def withPrefixedBinding(prefix: String, separator: Char): Parser = {
45+
prefixedBindings(prefix) = separator
46+
this
47+
}
48+
49+
def parseBinding(str: String, separator: Char): (String, String) = (str indexOf separator) match {
50+
case -1 => argumentError(s"missing '$separator' in binding '$str'") ; ("", "")
51+
case idx => ((str take idx).trim, (str drop (idx + 1)).trim)
52+
}
53+
54+
def parse(args: Array[String]): Arguments = {
55+
val res = new Arguments
56+
parse(args, res)
57+
res
58+
}
59+
60+
def parse(args: Array[String], res: Arguments) {
61+
if (args != null) {
62+
var i = 0
63+
while (i < args.length)
64+
if ((args(i) == null) || (args(i).length() == 0))
65+
i += 1
66+
else if (args(i).charAt(0) != optionPrefix) {
67+
res.addOther(args(i))
68+
i += 1
69+
} else if (options(args(i))) {
70+
res.addOption(args(i))
71+
i += 1
72+
} else if (optionalArgs contains args(i)) {
73+
if ((i + 1) == args.length) {
74+
argumentError(s"missing argument for '${args(i)}'")
75+
i += 1
76+
} else {
77+
res.addArgument(args(i), args(i + 1))
78+
i += 2
79+
}
80+
} else if (optionalBindings contains args(i)) {
81+
if ((i + 1) == args.length) {
82+
argumentError(s"missing argument for '${args(i)}'")
83+
i += 1
84+
} else {
85+
res.addBinding(args(i),
86+
parseBinding(args(i + 1), optionalBindings(args(i))))
87+
i += 2
88+
}
89+
} else {
90+
val iter = prefixes.iterator
91+
val j = i
92+
while ((i == j) && iter.hasNext) {
93+
val prefix = iter.next
94+
if (args(i) startsWith prefix) {
95+
res.addPrefixed(prefix, args(i).substring(prefix.length()).trim())
96+
i += 1
97+
}
98+
}
99+
if (i == j) {
100+
val iter = prefixedBindings.keysIterator
101+
while ((i == j) && iter.hasNext) {
102+
val prefix = iter.next
103+
if (args(i) startsWith prefix) {
104+
val arg = args(i).substring(prefix.length()).trim()
105+
i = i + 1
106+
res.addBinding(prefix,
107+
parseBinding(arg, prefixedBindings(prefix)))
108+
}
109+
}
110+
if (i == j) {
111+
argumentError(s"unknown option '${args(i)}'")
112+
i = i + 1
113+
}
114+
}
115+
}
116+
}
117+
}
118+
}
119+
120+
def parse(options: String*)(args: Array[String]): Arguments = {
121+
val parser = new Parser('-')
122+
options foreach parser.withOption
123+
parser parse args
124+
}
125+
}
126+
127+
class Arguments {
128+
private val options = new mutable.HashSet[String]
129+
private val arguments = new mutable.HashMap[String, String]
130+
private val prefixes = new mutable.HashMap[String, mutable.HashSet[String]]
131+
private val bindings = new mutable.HashMap[String, mutable.HashMap[String, String]]
132+
private val others = new ListBuffer[String]
133+
134+
def addOption(option: String): Unit = options += option
135+
136+
def addArgument(option: String, arg: String): Unit = arguments(option) = arg
137+
138+
def addPrefixed(prefix: String, arg: String): Unit =
139+
prefixes.getOrElseUpdate(prefix, new mutable.HashSet) += arg
140+
141+
def addBinding(tag: String, key: String, value: String): Unit =
142+
if (key.length > 0)
143+
bindings.getOrElseUpdate(tag, new mutable.HashMap)(key) = value
144+
145+
def addBinding(tag: String, binding: (String, String)): Unit =
146+
addBinding(tag, binding._1, binding._2)
147+
148+
def addOther(arg: String): Unit = others += arg
149+
150+
def contains(option: String): Boolean = options(option)
151+
152+
def getArgument(option: String): Option[String] = arguments get option
153+
154+
def getSuffixes(prefix: String): mutable.Set[String] =
155+
prefixes.getOrElse(prefix, new mutable.HashSet)
156+
157+
def containsSuffix(prefix: String, suffix: String): Boolean =
158+
prefixes get prefix exists (set => set(suffix))
159+
160+
def getBindings(tag: String): mutable.Map[String, String] =
161+
bindings.getOrElse(tag, new mutable.HashMap)
162+
163+
def getBinding(option: String, key: String): Option[String] =
164+
bindings get option flatMap (_ get key)
165+
166+
def getOthers: List[String] = others.toList
167+
}

‎src/main/resources/scalap/ByteArrayReader.scala

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,112 @@
1+
/* ___ ____ ___ __ ___ ___
2+
** / _// __// _ | / / / _ | / _ \ Scala classfile decoder
3+
** __\ \/ /__/ __ |/ /__/ __ |/ ___/ (c) 2003-2013, LAMP/EPFL
4+
** /____/\___/_/ |_/____/_/ |_/_/ http://scala-lang.org/
5+
**
6+
*/
7+
8+
9+
package scala
10+
package tools.scalap
11+
12+
13+
class ByteArrayReader(content: Array[Byte]) {
14+
15+
/** the buffer containing the file
16+
*/
17+
val buf: Array[Byte] = content
18+
19+
/** the current input pointer
20+
*/
21+
var bp: Int = 0
22+
23+
/** return byte at offset 'pos'
24+
*/
25+
def byteAt(pos: Int): Byte = buf(pos)
26+
27+
/** read a byte
28+
*/
29+
def nextByte: Byte = {
30+
bp += 1
31+
buf(bp - 1)
32+
}
33+
34+
/** read some bytes
35+
*/
36+
def nextBytes(len: Int): Array[Byte] = {
37+
val res = new Array[Byte](len)
38+
System.arraycopy(buf, bp, res, 0, len)
39+
bp += len
40+
res
41+
}
42+
43+
/** read a character
44+
*/
45+
def nextChar: Char = {
46+
bp += 2
47+
getChar(bp - 2)
48+
}
49+
50+
/** read an integer
51+
*/
52+
def nextInt: Int = {
53+
bp += 4
54+
getInt(bp - 4)
55+
}
56+
57+
/** read a long
58+
*/
59+
def nextLong: Long = {
60+
bp += 8
61+
getLong(bp - 8)
62+
}
63+
64+
/** read a float
65+
*/
66+
def nextFloat: Float = java.lang.Float.intBitsToFloat(nextInt)
67+
68+
/** read a double
69+
*/
70+
def nextDouble: Double = java.lang.Double.longBitsToDouble(nextLong)
71+
72+
/** read an UTF8 encoded string
73+
*/
74+
def nextUTF8(len: Int): String = {
75+
val cs = scala.io.Codec.fromUTF8(buf, bp, len)
76+
bp += len
77+
new String(cs)
78+
}
79+
80+
/** extract a character at position bp from buf
81+
*/
82+
def getChar(bp: Int): Char =
83+
(((buf(bp) & 0xff) << 8) + (buf(bp + 1) & 0xff)).asInstanceOf[Char]
84+
85+
/** extract an integer at position bp from buf
86+
*/
87+
def getInt(bp: Int): Int =
88+
((buf(bp ) & 0xff) << 24) +
89+
((buf(bp + 1) & 0xff) << 16) +
90+
((buf(bp + 2) & 0xff) << 8) +
91+
(buf(bp + 3) & 0xff)
92+
93+
/** extract a long integer at position bp from buf
94+
*/
95+
def getLong(bp: Int): Long =
96+
(getInt(bp).toLong << 32) + (getInt(bp + 4).toLong & 0xffffffffL)
97+
98+
/** extract a float at position bp from buf
99+
*/
100+
def getFloat(bp: Int): Float = java.lang.Float.intBitsToFloat(getInt(bp))
101+
102+
/** extract a double at position bp from buf
103+
*/
104+
def getDouble(bp: Int): Double = java.lang.Double.longBitsToDouble(getLong(bp))
105+
106+
/** skip next 'n' bytes
107+
*/
108+
def skip(n: Int) {
109+
bp += n
110+
}
111+
112+
}

0 commit comments

Comments
 (0)