Skip to content

Commit 702498e

Browse files
harpocratesharpocrates
committed
Use StringConcatFactory for string concatenation on JDK 9+
JEP 280, released in JDK 9, proposes a new way to compile string concatenation using `invokedynamic` and `StringConcatFactory`. This new approach generates less bytecode, doesn't have to incur the overhead of `StringBuilder` allocations, and allows users to pick swap the concatenation technique at runtime. This changes the codegen when the target is at least Java 9 to leverage `invokedynamic` and `StringConcatFactory`. On Java 8, the old `StringBuilder` approach is still used. Ported from scala#9556
1 parent ecbe3d2 commit 702498e

File tree

4 files changed

+209
-16
lines changed

4 files changed

+209
-16
lines changed

‎compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

Lines changed: 88 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1063,30 +1063,109 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
10631063
}
10641064
}
10651065

1066+
/* Generate string concatenation
1067+
*
1068+
* On JDK 8: create and append using `StringBuilder`
1069+
* On JDK 9+: use `invokedynamic` with `StringConcatFactory`
1070+
*/
10661071
def genStringConcat(tree: Tree): BType = {
10671072
lineNumber(tree)
10681073
liftStringConcat(tree) match {
1069-
// Optimization for expressions of the form "" + x. We can avoid the StringBuilder.
1074+
// Optimization for expressions of the form "" + x
10701075
case List(Literal(Constant("")), arg) =>
10711076
genLoad(arg, ObjectReference)
10721077
genCallMethod(defn.String_valueOf_Object, InvokeStyle.Static)
10731078

10741079
case concatenations =>
1075-
bc.genStartConcat
1076-
for (elem <- concatenations) {
1077-
val loadedElem = elem match {
1080+
val concatArguments = concatenations.view
1081+
.filter {
1082+
case Literal(Constant("")) => false // empty strings are no-ops in concatenation
1083+
case _ => true
1084+
}
1085+
.map {
10781086
case Apply(boxOp, value :: Nil) if Erasure.Boxing.isBox(boxOp.symbol) && boxOp.symbol.denot.owner != defn.UnitModuleClass =>
10791087
// Eliminate boxing of primitive values. Boxing is introduced by erasure because
10801088
// there's only a single synthetic `+` method "added" to the string class.
10811089
value
1090+
case other => other
1091+
}
1092+
.toList
1093+
1094+
// `StringConcatFactory` only got added in JDK 9, so use `StringBuilder` for lower
1095+
if (classfileVersion < asm.Opcodes.V9) {
1096+
1097+
// Estimate capacity needed for the string builder
1098+
val approxBuilderSize = concatArguments.view.map {
1099+
case Literal(Constant(s: String)) => s.length
1100+
case Literal(c @ Constant(_)) if c.isNonUnitAnyVal => String.valueOf(c).length
1101+
case _ => 0
1102+
}.sum
1103+
bc.genNewStringBuilder(approxBuilderSize)
1104+
1105+
for (elem <- concatArguments) {
1106+
val elemType = tpeTK(elem)
1107+
genLoad(elem, elemType)
1108+
bc.genStringBuilderAppend(elemType)
1109+
}
1110+
bc.genStringBuilderEnd
1111+
} else {
1112+
1113+
/* `StringConcatFactory#makeConcatWithConstants` accepts max 200 argument slots. If
1114+
* the string concatenation is longer (unlikely), we spill into multiple calls
1115+
*/
1116+
val MaxIndySlots = 200
1117+
val TagArg = '\u0001' // indicates a hole (in the recipe string) for an argument
1118+
val TagConst = '\u0002' // indicates a hole (in the recipe string) for a constant
1119+
1120+
val recipe = new StringBuilder()
1121+
val argTypes = Seq.newBuilder[asm.Type]
1122+
val constVals = Seq.newBuilder[String]
1123+
var totalArgSlots = 0
1124+
var countConcats = 1 // ie. 1 + how many times we spilled
1125+
1126+
for (elem <- concatArguments) {
1127+
val tpe = tpeTK(elem)
1128+
val elemSlots = tpe.size
1129+
1130+
// Unlikely spill case
1131+
if (totalArgSlots + elemSlots >= MaxIndySlots) {
1132+
bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result())
1133+
countConcats += 1
1134+
totalArgSlots = 0
1135+
recipe.setLength(0)
1136+
argTypes.clear()
1137+
constVals.clear()
1138+
}
10821139

1083-
case _ => elem
1140+
elem match {
1141+
case Literal(Constant(s: String)) =>
1142+
if (s.contains(TagArg) || s.contains(TagConst)) {
1143+
totalArgSlots += elemSlots
1144+
recipe.append(TagConst)
1145+
constVals += s
1146+
} else {
1147+
recipe.append(s)
1148+
}
1149+
1150+
case other =>
1151+
totalArgSlots += elemSlots
1152+
recipe.append(TagArg)
1153+
val tpe = tpeTK(elem)
1154+
argTypes += tpe.toASMType
1155+
genLoad(elem, tpe)
1156+
}
1157+
}
1158+
bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result())
1159+
1160+
// If we spilled, generate one final concat
1161+
if (countConcats > 1) {
1162+
bc.genIndyStringConcat(
1163+
TagArg.toString * countConcats,
1164+
Seq.fill(countConcats)(StringRef.toASMType),
1165+
Seq.empty
1166+
)
10841167
}
1085-
val elemType = tpeTK(loadedElem)
1086-
genLoad(loadedElem, elemType)
1087-
bc.genConcat(elemType)
10881168
}
1089-
bc.genEndConcat
10901169
}
10911170
StringRef
10921171
}

‎compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala

Lines changed: 35 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -224,24 +224,27 @@ trait BCodeIdiomatic {
224224

225225
} // end of method genPrimitiveShift()
226226

227-
/*
227+
/* Creates a new `StringBuilder` instance with the requested capacity
228+
*
228229
* can-multi-thread
229230
*/
230-
final def genStartConcat: Unit = {
231+
final def genNewStringBuilder(size: Int): Unit = {
231232
jmethod.visitTypeInsn(Opcodes.NEW, JavaStringBuilderClassName)
232233
jmethod.visitInsn(Opcodes.DUP)
234+
jmethod.visitLdcInsn(Integer.valueOf(size))
233235
invokespecial(
234236
JavaStringBuilderClassName,
235237
INSTANCE_CONSTRUCTOR_NAME,
236-
"()V",
238+
"(I)V",
237239
itf = false
238240
)
239241
}
240242

241-
/*
243+
/* Issue a call to `StringBuilder#append` for the right element type
244+
*
242245
* can-multi-thread
243246
*/
244-
def genConcat(elemType: BType): Unit = {
247+
final def genStringBuilderAppend(elemType: BType): Unit = {
245248
val paramType = elemType match {
246249
case ct: ClassBType if ct.isSubtypeOf(StringRef) => StringRef
247250
case ct: ClassBType if ct.isSubtypeOf(jlStringBufferRef) => jlStringBufferRef
@@ -257,13 +260,38 @@ trait BCodeIdiomatic {
257260
invokevirtual(JavaStringBuilderClassName, "append", bt.descriptor)
258261
}
259262

260-
/*
263+
/* Extract the built `String` from the `StringBuilder`
264+
*
261265
* can-multi-thread
262266
*/
263-
final def genEndConcat: Unit = {
267+
final def genStringBuilderEnd: Unit = {
264268
invokevirtual(JavaStringBuilderClassName, "toString", "()Ljava/lang/String;")
265269
}
266270

271+
/* Concatenate top N arguments on the stack with `StringConcatFactory#makeConcatWithConstants`
272+
* (only works for JDK 9+)
273+
*
274+
* can-multi-thread
275+
*/
276+
final def genIndyStringConcat(
277+
recipe: String,
278+
argTypes: Seq[asm.Type],
279+
constants: Seq[String]
280+
): Unit = {
281+
jmethod.visitInvokeDynamicInsn(
282+
"makeConcatWithConstants",
283+
asm.Type.getMethodDescriptor(StringRef.toASMType, argTypes:_*),
284+
new asm.Handle(
285+
asm.Opcodes.H_INVOKESTATIC,
286+
"java/lang/invoke/StringConcatFactory",
287+
"makeConcatWithConstants",
288+
"(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;",
289+
false
290+
),
291+
(recipe +: constants):_*
292+
)
293+
}
294+
267295
/*
268296
* Emits one or more conversion instructions based on the types given as arguments.
269297
*

‎tests/disabled/partest/run/StringConcat.check

5.46 KB
Binary file not shown.

‎tests/disabled/partest/run/StringConcat.scala

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
// java: -Xss128M
2+
3+
import scala.tools.partest.ReplTest
4+
5+
// ReplTest so that the long concatenation is compiled at test-run-time with the larger `Xss`.
6+
// Tests are always compiled in the partest VM.
7+
object Test extends ReplTest {
8+
def code =
9+
"""// This should generally obey 15.18.1. of the JLS (String Concatenation Operator +)
10+
|def concatenatingVariousTypes(): String = {
11+
| val str: String = "some string"
12+
| val sb: StringBuffer = new StringBuffer("some stringbuffer")
13+
| val cs: CharSequence = java.nio.CharBuffer.allocate(50).append("charsequence")
14+
| val i: Int = 123456789
15+
| val s: Short = 345
16+
| val b: Byte = 12
17+
| val z: Boolean = true
18+
| val f: Float = 3.14f
19+
| val j: Long = 98762147483647L
20+
| val d: Double = 3.1415d
21+
|
22+
| "String " + str + "\n" +
23+
| "StringBuffer " + sb + "\n" +
24+
| "CharSequence " + cs + "\n" +
25+
| "Int " + i + "\n" +
26+
| "Short " + s + "\n" +
27+
| "Byte " + b + "\n" +
28+
| "Boolean " + z + "\n" +
29+
| "Float " + f + "\n" +
30+
| "Long " + j + "\n" +
31+
| "Double " + d + "\n"
32+
|}
33+
|// The characters `\u0001` and `\u0002` play a special role in `StringConcatFactory`
34+
|def concatenationInvolvingSpecialCharacters(): String = {
35+
| val s1 = "Qux"
36+
| val s2 = "Quux"
37+
|
38+
| s"Foo \u0001 $s1 Bar \u0002 $s2 Baz"
39+
|}
40+
|// Concatenation involving more than 200 elements
41+
|def largeConcatenation(): String = {
42+
| val s00 = "s00"
43+
| val s01 = "s01"
44+
| val s02 = "s02"
45+
| val s03 = "s03"
46+
| val s04 = "s04"
47+
| val s05 = "s05"
48+
| val s06 = "s06"
49+
| val s07 = "s07"
50+
| val s08 = "s08"
51+
|
52+
| // 24 rows follow
53+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
54+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
55+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
56+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
57+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
58+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
59+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
60+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
61+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
62+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
63+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
64+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
65+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
66+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
67+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
68+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
69+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
70+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
71+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
72+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
73+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
74+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
75+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n" +
76+
| s00 + "," + s01 + "," + s02 + "," + s03 + "," + s04 + "," + s05 + "," + s06 + "," + s07 + "," + s08 + "\n"
77+
|}
78+
|println("----------")
79+
|println(concatenatingVariousTypes())
80+
|println("----------")
81+
|println(concatenationInvolvingSpecialCharacters())
82+
|println("----------")
83+
|println(largeConcatenation())
84+
|println("----------")
85+
|""".stripMargin
86+
}

0 commit comments

Comments
 (0)