291 lines
12 KiB
Kotlin
291 lines
12 KiB
Kotlin
package com.jaytux.simd.data
|
|
|
|
import com.fleeksoft.ksoup.Ksoup
|
|
import com.fleeksoft.ksoup.parser.Parser
|
|
import com.jaytux.simd.data.IntrinsicInstructions.xed
|
|
import kotlinx.coroutines.coroutineScope
|
|
import kotlinx.datetime.*
|
|
import kotlinx.datetime.format.MonthNames
|
|
import kotlinx.serialization.Serializable
|
|
import kotlinx.serialization.json.Json
|
|
import kotlinx.serialization.json.JsonObject
|
|
import org.jetbrains.exposed.sql.batchInsert
|
|
import org.jetbrains.exposed.sql.insert
|
|
import org.jetbrains.exposed.sql.transactions.transaction
|
|
import java.io.File
|
|
import org.json.JSONObject
|
|
import org.junit.jupiter.api.DisplayNameGenerator.Simple
|
|
import java.text.DateFormat
|
|
import java.text.SimpleDateFormat
|
|
import java.util.Date
|
|
import java.util.prefs.Preferences
|
|
|
|
object Loader {
|
|
private val cache = Preferences.userNodeForPackage(this::class.java)
|
|
private val intelDateTimeFormat = LocalDate.Format {
|
|
monthNumber(); chars("/"); dayOfMonth(); chars("/"); year();
|
|
}
|
|
private val dateFormat = LocalDate.Format {
|
|
dayOfMonth(); chars("-"); monthName(MonthNames.ENGLISH_FULL); chars("-"); year()
|
|
}
|
|
private val zero = LocalDate(1970, 1, 1)
|
|
|
|
data class XmlIntrinsic(val name: String, val tech: String, val retType: String, val retVar: String?,
|
|
val args: List<Pair<String, String>>, val desc: String, val op: String?,
|
|
val insn: List<Triple<String, String, String?>>, val cpuid: String?, val category: String
|
|
)
|
|
|
|
data class Version(val major: Int, val minor: Int, val patch: Int) {
|
|
override fun toString(): String = "$major.$minor.$patch"
|
|
|
|
infix fun isNewerThan(other: Version): Boolean {
|
|
if(major > other.major) return true
|
|
if(major == other.major && minor > other.minor) return true
|
|
if(major == other.major && minor == other.minor && patch > other.patch) return true
|
|
return false
|
|
}
|
|
|
|
companion object {
|
|
fun fromString(version: String): Version {
|
|
val parts = version.split(".")
|
|
return Version(parts[0].toInt(), parts[1].toInt(), parts[2].toInt())
|
|
}
|
|
}
|
|
}
|
|
|
|
data class DatedVersion(val version: Version, val releaseDate: LocalDate, val updateDate: LocalDate) {
|
|
override fun toString(): String = "$version (remote released ${dateFormat.format(releaseDate)}; local updated ${dateFormat.format(updateDate)})"
|
|
|
|
companion object {
|
|
fun fromPrefs(): DatedVersion {
|
|
val v = cache.get("version", null)?.let { Version.fromString(it) } ?: Version(0, 0, 0)
|
|
val r = cache.get("release", null)?.let { dateFormat.parse(it) } ?: zero
|
|
val u = cache.get("update", null)?.let { dateFormat.parse(it) } ?: zero
|
|
|
|
return DatedVersion(v, r, u)
|
|
}
|
|
}
|
|
}
|
|
|
|
data class XmlData(
|
|
val version: DatedVersion,
|
|
val types: Set<String>, val techs: Set<String>, val cpuids: Set<String>, val categories: Set<String>,
|
|
val intrinsics: List<XmlIntrinsic>
|
|
)
|
|
|
|
data class Performance(val latency: Float?, val throughput: Float?)
|
|
|
|
data class JsonData(val platforms: Set<String>, val data: Map<String, Map<String, Performance>>)
|
|
|
|
private suspend fun updateVersion(version: DatedVersion) = coroutineScope {
|
|
cache.put("version", version.version.toString())
|
|
cache.put("release", dateFormat.format(version.releaseDate))
|
|
cache.put("update", dateFormat.format(version.updateDate))
|
|
}
|
|
|
|
suspend fun loadXml(xmlFile: String): XmlData = coroutineScope {
|
|
val xml = Ksoup.parseXml(File(xmlFile).readText(Charsets.UTF_8))
|
|
Parser.xmlParser()
|
|
|
|
val cppTypes = mutableSetOf<String>()
|
|
val techs = mutableSetOf<String>()
|
|
val cpuids = mutableSetOf<String>()
|
|
val categories = mutableSetOf<String>()
|
|
val intrins = mutableListOf<XmlIntrinsic>()
|
|
|
|
val errors = mutableListOf<String>()
|
|
|
|
val (version, release) = xml.getElementsByTag("intrinsics_list").firstOrNull()?.let {
|
|
val version = it.attribute("version")?.value?.let { v -> Version.fromString(v) }
|
|
if(version == null) {
|
|
errors += "Missing version attribute in intrinsics_list element"
|
|
return@let null
|
|
}
|
|
val date = it.attribute("date")?.value?.let { d -> intelDateTimeFormat.parse(d) }
|
|
if(date == null) {
|
|
errors += "Missing release_date attribute in intrinsics_list element"
|
|
return@let null
|
|
}
|
|
|
|
version to date
|
|
} ?: Version(0, 0, 0) to LocalDate.fromEpochDays(0) // dummy data
|
|
|
|
if(errors.isNotEmpty()) {
|
|
errors.forEach { System.err.println(it) }
|
|
throw Exception("XML file is (partially) invalid")
|
|
}
|
|
|
|
val update = Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
|
|
|
|
xml.getElementsByTag("intrinsic").forEachIndexed { i, it ->
|
|
val name = it.attribute("name")?.value
|
|
if(name == null) {
|
|
errors += "Missing name attribute in intrinsic element"
|
|
return@forEachIndexed
|
|
}
|
|
val tech = it.attribute("tech")?.value
|
|
if(tech == null) {
|
|
errors += "Missing tech attribute for intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
|
|
val ret = it.getElementsByTag("return").firstOrNull()
|
|
if(ret == null) {
|
|
errors += "Missing return element for intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
val retType = ret.attribute("type")?.value
|
|
if(retType == null) {
|
|
errors += "Missing type attribute for return element in intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
val retVar = ret.attribute("varname")?.value
|
|
|
|
val args = mutableListOf<Pair<String, String>>()
|
|
it.getElementsByTag("parameter").forEachIndexed { i, p ->
|
|
val argName = p.attribute("varname")?.value
|
|
val type = p.attribute("type")?.value
|
|
|
|
if(type != null && type == "void") return@forEachIndexed //ignore
|
|
|
|
if(argName == null) {
|
|
errors += "Missing varname attribute for parameter $i in intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
if(type == null) {
|
|
errors += "Missing type attribute for parameter $argName in intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
cppTypes += type
|
|
args += argName to type
|
|
}
|
|
|
|
val desc = it.getElementsByTag("description").firstOrNull()?.wholeText()?.trim()
|
|
if(desc == null) {
|
|
errors += "Missing description element for intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
|
|
val op = it.getElementsByTag("operation").firstOrNull()?.wholeText()?.trim()
|
|
|
|
val insn = mutableListOf<Triple<String, String, String?>>()
|
|
it.getElementsByTag("instruction").forEachIndexed { i, ins ->
|
|
val insnName = ins.attribute("xed")?.value ?: ins.attribute("name")?.value
|
|
if(insnName == null) {
|
|
errors += "Missing both xed and name attribute for instruction $i in intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
val insnMnemonic = ins.attribute("name")?.value
|
|
if(insnMnemonic == null) {
|
|
errors += "Missing name attribute for instruction $insnName in intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
val insnForm = ins.attribute("form")?.value
|
|
insn += Triple(insnName, insnMnemonic, insnForm)
|
|
}
|
|
|
|
val cpuid = it.getElementsByTag("cpuid").firstOrNull()?.text()
|
|
|
|
val category = it.getElementsByTag("category").firstOrNull()?.text()
|
|
if(category == null) {
|
|
errors += "Missing category element for intrinsic $name"
|
|
return@forEachIndexed
|
|
}
|
|
|
|
val intrinsic = XmlIntrinsic(name, tech, retType, retVar, args, desc, op, insn, cpuid, category)
|
|
intrins += intrinsic
|
|
techs += tech
|
|
cpuid?.let { c -> cpuids += c }
|
|
categories += category
|
|
cppTypes += retType
|
|
}
|
|
|
|
if(errors.isNotEmpty()) {
|
|
errors.forEach { System.err.println(it) }
|
|
throw Exception("XML file is (partially) invalid")
|
|
}
|
|
|
|
XmlData(version = DatedVersion(version, release, update),
|
|
types = cppTypes, techs = techs, cpuids = cpuids, categories = categories,
|
|
intrinsics = intrins
|
|
)
|
|
}
|
|
|
|
suspend fun loadJson(jsonFile: String): JsonData = coroutineScope {
|
|
val json = File(jsonFile).readText(Charsets.UTF_8)
|
|
val schema = JSONObject(json)
|
|
val pSet = mutableSetOf<String>()
|
|
val res = mutableMapOf<String, MutableMap<String, Performance>>()
|
|
|
|
schema.keys().forEach { opcode ->
|
|
val pMap = mutableMapOf<String, Performance>()
|
|
val platforms = schema.getJSONArray(opcode)
|
|
for (i in 0 until platforms.length()) {
|
|
val platform = platforms.getJSONObject(i)
|
|
|
|
platform.keys().forEach { k ->
|
|
pSet += k
|
|
val latency = platform.getJSONObject(k).getString("l").toFloatOrNull()
|
|
val throughput = platform.getJSONObject(k).getString("t").toFloatOrNull()
|
|
pMap += k to Performance(latency, throughput)
|
|
}
|
|
}
|
|
res += opcode to pMap
|
|
}
|
|
|
|
JsonData(pSet, res)
|
|
}
|
|
|
|
suspend fun importToDb(xml: XmlData, json: JsonData) = coroutineScope {
|
|
val db = Database.db
|
|
transaction {
|
|
val techMap = xml.techs.associateWith { tech -> Tech.new { name = tech } }
|
|
val typeMap = xml.types.associateWith { type -> CppType.new { name = type } }
|
|
val catMap = xml.categories.associateWith { cat -> Category.new { name = cat } }
|
|
val cpuidMap = xml.cpuids.associateWith { cpuid -> CPUID.new { name = cpuid } }
|
|
val platformMap = json.platforms.associateWith { platform -> Platform.new { name = platform } }
|
|
|
|
xml.intrinsics.forEach { intr ->
|
|
val dbIn = Intrinsic.new {
|
|
mnemonic = intr.name
|
|
returnType = typeMap[intr.retType] ?: throw Exception("Type ${intr.retType} not found")
|
|
returnVar = intr.retVar
|
|
description = intr.desc
|
|
operations = intr.op
|
|
category = catMap[intr.category] ?: throw Exception("Category ${intr.category} not found")
|
|
cpuid = intr.cpuid?.let { cpuidMap[it] ?: throw Exception("CPUID ${intr.cpuid} not found") }
|
|
tech = techMap[intr.tech] ?: throw Exception("Tech ${intr.tech} not found")
|
|
}
|
|
|
|
intr.args.forEachIndexed { i, arg ->
|
|
IntrinsicArgument.new {
|
|
intrinsic = dbIn
|
|
name = arg.first
|
|
type = typeMap[arg.second] ?: throw Exception("Type ${arg.second} not found")
|
|
index = i
|
|
}
|
|
}
|
|
|
|
intr.insn.forEach { insn ->
|
|
val dbInsn = IntrinsicInstruction.new {
|
|
intrinsic = dbIn
|
|
xed = insn.first
|
|
mnemonic = insn.second
|
|
insn.third?.let { form = it }
|
|
}
|
|
|
|
json.data[insn.first]?.forEach { (pl, perf) ->
|
|
val dbPl = platformMap[pl] ?: throw Exception("Platform $pl not found")
|
|
Performances.insert {
|
|
it[instruction] = dbInsn.id
|
|
it[platform] = dbPl.id
|
|
it[latency] = perf.latency
|
|
it[throughput] = perf.throughput
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
updateVersion(xml.version)
|
|
}
|
|
} |