Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-05 15:28:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Improved assembly performance in JS.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2021-04-18 20:30:15 +02:00
parent 5c0b7a20f0
commit feec12b308
3 changed files with 45 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
core/src/commonMain/kotlin/world/phantasmal/core/PrimitiveExtensions.kt
View File

@ -1,5 +1,10 @@
package world.phantasmal.core package world.phantasmal.core
// Char.isWhitespace is very slow in JS, use this until
// https://youtrack.jetbrains.com/issue/KT-43216 lands.
fun Char.fastIsWhitespace(): Boolean =
this == ' ' || this in '\u0009'..'\u000D'
fun Char.isDigit(): Boolean = this in '0'..'9' fun Char.isDigit(): Boolean = this in '0'..'9'
/** /**

11
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt
View File

@ -1,5 +1,6 @@
package world.phantasmal.lib.asm package world.phantasmal.lib.asm
import world.phantasmal.core.fastIsWhitespace
import world.phantasmal.core.isDigit import world.phantasmal.core.isDigit
private val HEX_INT_REGEX = Regex("""^0[xX][0-9a-fA-F]+$""") private val HEX_INT_REGEX = Regex("""^0[xX][0-9a-fA-F]+$""")
@ -119,7 +120,7 @@ private class LineTokenizer(private var line: String) {
} }
} }
if (char.isWhitespace()) { if (char.fastIsWhitespace()) {
skip() skip()
continue continue
} else if (char == '-' || char.isDigit()) { } else if (char == '-' || char.isDigit()) {
@ -169,7 +170,7 @@ private class LineTokenizer(private var line: String) {
while (hasNext()) { while (hasNext()) {
val char = next() val char = next()
if (char == ',' || char.isWhitespace()) { if (char == ',' || char.fastIsWhitespace()) {
back() back()
break break
} }
@ -192,7 +193,7 @@ private class LineTokenizer(private var line: String) {
} else if (char == ':') { } else if (char == ':') {
isLabel = true isLabel = true
break break
} else if (char == ',' || char.isWhitespace()) { } else if (char == ',' || char.fastIsWhitespace()) {
break break
} else { } else {
skip() skip()
@ -274,7 +275,7 @@ private class LineTokenizer(private var line: String) {
mark() mark()
while (hasNext()) { while (hasNext()) {
if (peek().isWhitespace()) { if (peek().fastIsWhitespace()) {
break break
} else { } else {
skip() skip()
@ -336,7 +337,7 @@ private class LineTokenizer(private var line: String) {
while (hasNext()) { while (hasNext()) {
val char = peek() val char = peek()
if (char == ',' || char.isWhitespace()) { if (char == ',' || char.fastIsWhitespace()) {
break break
} else if (char == '/') { } else if (char == '/') {
skip() skip()

58
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt
View File

@ -369,9 +369,11 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
val lastToken = tokens.lastOrNull() val lastToken = tokens.lastOrNull()
val errorLength = lastToken?.let { it.col + it.len - identToken.col } ?: 0 val errorLength = lastToken?.let { it.col + it.len - identToken.col } ?: 0
// Inline arguments. // Inline arguments.
val insArgAndTokens = mutableListOf<Pair<Arg, Token>>() val inlineArgs = mutableListOf<Arg>()
val inlineTokens = mutableListOf<Token>()
// Stack arguments. // Stack arguments.
val stackArgAndTokens = mutableListOf<Pair<Arg, Token>>() val stackArgs = mutableListOf<Arg>()
val stackTokens = mutableListOf<Token>()
if (!varargs && argCount != paramCount) { if (!varargs && argCount != paramCount) {
addError( addError(
@ -397,19 +399,19 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
return return
} else if (opcode.stack !== StackInteraction.Pop) { } else if (opcode.stack !== StackInteraction.Pop) {
// Arguments should be inlined right after the opcode. // Arguments should be inlined right after the opcode.
if (!parseArgs(opcode.params, insArgAndTokens, stack = false)) { if (!parseArgs(opcode.params, inlineArgs, inlineTokens, stack = false)) {
return return
} }
} else { } else {
// Arguments should be passed to the opcode via the stack. // Arguments should be passed to the opcode via the stack.
if (!parseArgs(opcode.params, stackArgAndTokens, stack = true)) { if (!parseArgs(opcode.params, stackArgs, stackTokens, stack = true)) {
return return
} }
for (i in opcode.params.indices) { for (i in opcode.params.indices) {
val param = opcode.params[i] val param = opcode.params[i]
val argAndToken = stackArgAndTokens.getOrNull(i) ?: continue val arg = stackArgs.getOrNull(i) ?: continue
val (arg, argToken) = argAndToken val argToken = stackTokens.getOrNull(i) ?: continue
if (argToken is Token.Register) { if (argToken is Token.Register) {
if (param.type is RegTupRefType) { if (param.type is RegTupRefType) {
@ -499,15 +501,12 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
} }
} }
val (args, argTokens) = insArgAndTokens.unzip()
val stackArgTokens = stackArgAndTokens.map { it.second }
addInstruction( addInstruction(
opcode, opcode,
args, inlineArgs,
identToken, identToken,
argTokens, inlineTokens,
stackArgTokens, stackTokens,
) )
} }
} }
@ -517,7 +516,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
*/ */
private fun parseArgs( private fun parseArgs(
params: List<Param>, params: List<Param>,
argAndTokens: MutableList<Pair<Arg, Token>>, args: MutableList<Arg>,
argTokens: MutableList<Token>,
stack: Boolean, stack: Boolean,
): Boolean { ): Boolean {
var semiValid = true var semiValid = true
@ -556,7 +556,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
when (param.type) { when (param.type) {
is ByteType -> { is ByteType -> {
match = true match = true
parseInt(1, token, argAndTokens) parseInt(1, token, args, argTokens)
} }
is ShortType, is ShortType,
is LabelType, is LabelType,
@ -566,15 +566,16 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
is ILabelVarType, is ILabelVarType,
-> { -> {
match = true match = true
parseInt(2, token, argAndTokens) parseInt(2, token, args, argTokens)
} }
is IntType -> { is IntType -> {
match = true match = true
parseInt(4, token, argAndTokens) parseInt(4, token, args, argTokens)
} }
is FloatType -> { is FloatType -> {
match = true match = true
argAndTokens.add(Pair(Arg(token.value), token)) args.add(Arg(token.value))
argTokens.add(token)
} }
else -> { else -> {
match = false match = false
@ -586,7 +587,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
match = param.type == FloatType match = param.type == FloatType
if (match) { if (match) {
argAndTokens.add(Pair(Arg(token.value), token)) args.add(Arg(token.value))
argTokens.add(token)
} }
} }
@ -596,14 +598,15 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
param.type is RegRefVarType || param.type is RegRefVarType ||
param.type is RegTupRefType param.type is RegTupRefType
parseRegister(token, argAndTokens) parseRegister(token, args, argTokens)
} }
is Token.Str -> { is Token.Str -> {
match = param.type is StringType match = param.type is StringType
if (match) { if (match) {
argAndTokens.add(Pair(Arg(token.value), token)) args.add(Arg(token.value))
argTokens.add(token)
} }
} }
@ -653,7 +656,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
private fun parseInt( private fun parseInt(
size: Int, size: Int,
token: Token.Int32, token: Token.Int32,
argAndTokens: MutableList<Pair<Arg, Token>>, args: MutableList<Arg>,
argTokens: MutableList<Token>,
) { ) {
val value = token.value val value = token.value
val bitSize = 8 * size val bitSize = 8 * size
@ -670,18 +674,24 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
addError(token, "${bitSize}-Bit integer can't be greater than ${maxValue}.") addError(token, "${bitSize}-Bit integer can't be greater than ${maxValue}.")
} }
else -> { else -> {
argAndTokens.add(Pair(Arg(value), token)) args.add(Arg(value))
argTokens.add(token)
} }
} }
} }
private fun parseRegister(token: Token.Register, argAndTokens: MutableList<Pair<Arg, Token>>) { private fun parseRegister(
token: Token.Register,
args: MutableList<Arg>,
argTokens: MutableList<Token>,
) {
val value = token.value val value = token.value
if (value > 255) { if (value > 255) {
addError(token, "Invalid register reference, expected r0-r255.") addError(token, "Invalid register reference, expected r0-r255.")
} else { } else {
argAndTokens.add(Pair(Arg(value), token)) args.add(Arg(value))
argTokens.add(token)
} }
} }