mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
Log the GPU ceiling and mid-session clock hold changes (#2893)
* Log the GPU ceiling, steps and mid-session clock hold changes The clock log now records the GPU frequency steps and floor once in its header, probes each limit file as readable or refused, and adds the allowed GPU maximum to every sample in the CPU cur/max(of top) style, so a vendor or thermal cap on the GPU ceiling shows up and changes during a session are visible. Samples are unchanged when no limit file is readable. The limit reading is shared with the device info GPU clock range. Turning the GPU clock hold on or off during a session now logs the same line the session start logs. * Ignore a zero GPU ceiling and log hold changes in order A ceiling file that reads zero is no longer printed as a limit and is listed as refused, matching how the step list is read. The hold state line is logged under the same lock as the state change, so overlapping toggles cannot log out of order. * Find a GPU ceiling that turns readable later and probe step tables as tables A ceiling file that read zero at session start is looked for again on each sample until one is found, and the log notes where it came from. Step and floor sources are probed with the same parser that reads them, so a table with a leading zero is listed as readable.
This commit is contained in:
1 parent
de73e429cc
commit
cc93ab51c5
7 files changed
+192
-34
No files matched your search
@@ -1471,7 +1471,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
|
||||
SessionPrefs.setGpuClockPin(this@SessionActivity, on)
|
||||
gpuClockPin = on
|
||||
Thread {
|
||||
GpuClockPin.sync(applicationContext)
|
||||
synchronized(GpuClockPin) { GpuClockPin.sync(applicationContext)?.let { Log.i(TAG, it) } }
|
||||
runOnUiThread { gpuClockPin = gpuClockHeld() }
|
||||
}.start()
|
||||
},
|
||||
|
||||
@@ -37,22 +37,22 @@ class ClockLogComponent(private val logFile: File) : SessionPart() {
|
||||
?.sortedBy { it.name.removePrefix("policy").toIntOrNull() ?: 0 } ?: emptyList()
|
||||
val gpuCandidates = gpuSources()
|
||||
val gpu = gpuCandidates.firstOrNull { !it.startsWith("/proc/") && firstNumber(it) != null }
|
||||
val stepSources = GpuLimits.stepSources()
|
||||
val maxSources = GpuLimits.maxSources()
|
||||
val minSources = GpuLimits.minSources()
|
||||
val steps = GpuLimits.first(stepSources)
|
||||
var ceiling = ceilingSource(maxSources)
|
||||
val power = app().getSystemService(Context.POWER_SERVICE) as? PowerManager
|
||||
val time = SimpleDateFormat("HH:mm:ss", Locale.US)
|
||||
try {
|
||||
FileWriter(logFile, true).use { w ->
|
||||
w.write("== clocks: ${Build.MANUFACTURER} ${Build.MODEL} (${Build.HARDWARE}), every ${PERIOD_MS / 1000}s\n")
|
||||
w.write("cpu policies: ${policies.joinToString { p -> p.name + " " + (File(p, "related_cpus").readTextOrNull()?.trim() ?: "?") }}\n")
|
||||
for (source in gpuCandidates) {
|
||||
val f = File(source)
|
||||
val state = when {
|
||||
!f.exists() -> continue
|
||||
firstNumber(source) != null -> "readable"
|
||||
else -> "refused"
|
||||
}
|
||||
w.write("gpu source $source: $state\n")
|
||||
}
|
||||
probeLines("gpu source", gpuCandidates).forEach { w.write(it + "\n") }
|
||||
w.write("gpu clock from: ${gpu ?: "nothing readable"}\n")
|
||||
(probeLines("gpu limit", stepSources, ::firstStep) + probeLines("gpu limit", maxSources, ::limit) +
|
||||
probeLines("gpu limit", minSources, ::firstStep)).distinct().forEach { w.write(it + "\n") }
|
||||
limitLines(steps, ceiling, GpuLimits.first(minSources)).forEach { w.write(it + "\n") }
|
||||
w.flush()
|
||||
while (running && logFile.length() < MAX_BYTES) {
|
||||
val line = StringBuilder(time.format(Date()))
|
||||
@@ -63,7 +63,8 @@ class ClockLogComponent(private val logFile: File) : SessionPart() {
|
||||
line.append(" ${p.name.removePrefix("policy").let { "p$it" }} ${mhz(cur)}/${mhz(max)}")
|
||||
if (hw != null && max != null && max < hw) line.append("(of ${mhz(hw)})")
|
||||
}
|
||||
gpu?.let { line.append(" | gpu ${mhz(firstNumber(it))} MHz") }
|
||||
if (ceiling == null) ceiling = ceilingSource(maxSources)?.also { w.write("gpu ceiling from: $it\n") }
|
||||
line.append(gpuField(gpu, ceiling, steps?.mhz?.last()))
|
||||
if (power != null && Build.VERSION.SDK_INT >= 29) {
|
||||
line.append(" | thermal ${power.currentThermalStatus}")
|
||||
if (Build.VERSION.SDK_INT >= 30) {
|
||||
@@ -109,16 +110,41 @@ class ClockLogComponent(private val logFile: File) : SessionPart() {
|
||||
return list.distinct()
|
||||
}
|
||||
|
||||
internal fun probeLines(label: String, sources: List<String>, read: (String) -> Long? = ::firstNumber): List<String> = sources.mapNotNull { source ->
|
||||
when {
|
||||
!File(source).exists() -> null
|
||||
read(source) != null -> "$label $source: readable"
|
||||
else -> "$label $source: refused"
|
||||
}
|
||||
}
|
||||
|
||||
internal fun limitLines(steps: GpuLimits.Found?, ceiling: String?, floor: GpuLimits.Found?): List<String> = listOf(
|
||||
"gpu steps: " + (steps?.let { "${it.mhz.joinToString(" ")} MHz from ${it.path}" } ?: "nothing readable"),
|
||||
"gpu ceiling from: " + (ceiling ?: "nothing readable"),
|
||||
"gpu floor: " + (floor?.let { "${it.mhz.first()} MHz from ${it.path}" } ?: "nothing readable"),
|
||||
)
|
||||
|
||||
internal fun gpuField(clock: String?, ceiling: String?, top: Long?): String {
|
||||
if (clock == null && ceiling == null) return ""
|
||||
val field = StringBuilder(" | gpu ").append(mhz(clock?.let(::firstNumber)))
|
||||
ceiling?.let(::limit)?.let { max ->
|
||||
field.append('/').append(mhz(max))
|
||||
if (top != null && GpuLimits.mhz(max) < top) field.append("(of $top)")
|
||||
}
|
||||
return field.append(" MHz").toString()
|
||||
}
|
||||
|
||||
private fun File.readTextOrNull(): String? = runCatching { readText() }.getOrNull()
|
||||
|
||||
private fun firstNumber(path: String): Long? =
|
||||
runCatching { Regex("\\d+").find(File(path).readText())?.value?.toLong() }.getOrNull()
|
||||
|
||||
private fun mhz(raw: Long?): String = when {
|
||||
raw == null -> "?"
|
||||
raw > 10_000_000 -> (raw / 1_000_000).toString()
|
||||
raw > 10_000 -> (raw / 1_000).toString()
|
||||
else -> raw.toString()
|
||||
}
|
||||
internal fun limit(path: String): Long? = firstNumber(path)?.takeIf { it > 0 }
|
||||
|
||||
internal fun firstStep(path: String): Long? = GpuLimits.read(path).firstOrNull()
|
||||
|
||||
internal fun ceilingSource(sources: List<String>): String? = sources.firstOrNull { limit(it) != null }
|
||||
|
||||
private fun mhz(raw: Long?): String = raw?.let { GpuLimits.mhz(it).toString() } ?: "?"
|
||||
}
|
||||
}
|
||||
@@ -87,20 +87,10 @@ object DeviceInfo {
|
||||
private fun ghz(khz: Long) = String.format(Locale.US, "%.2f GHz", khz / 1e6)
|
||||
|
||||
private fun gpuRange(): String? {
|
||||
fun mhz(hz: Long) = "${hz / 1_000_000} MHz"
|
||||
val kgsl = read("/sys/class/kgsl/kgsl-3d0/gpu_available_frequencies")
|
||||
?.split(Regex("\\s+"))?.mapNotNull { it.toLongOrNull() }?.filter { it > 0 }.orEmpty()
|
||||
if (kgsl.isNotEmpty()) return "${mhz(kgsl.min())}–${mhz(kgsl.max())} (${kgsl.size} steps)"
|
||||
read("/sys/class/kgsl/kgsl-3d0/max_gpuclk")?.toLongOrNull()?.let { return "up to ${mhz(it)}" }
|
||||
val node = File("/sys/class/devfreq").listFiles()?.firstOrNull { f ->
|
||||
val n = f.name.lowercase()
|
||||
(n.contains("gpu") || n.contains("mali") || n.contains("kgsl-3d")) && listOf("bus", "bw", "memlat").none { n.contains(it) }
|
||||
} ?: return null
|
||||
val steps = read("${node.path}/available_frequencies")?.split(Regex("\\s+"))?.mapNotNull { it.toLongOrNull() }?.filter { it > 0 }.orEmpty()
|
||||
if (steps.isNotEmpty()) return "${mhz(steps.min())}–${mhz(steps.max())} (${steps.size} steps)"
|
||||
val min = read("${node.path}/min_freq")?.toLongOrNull()
|
||||
val max = read("${node.path}/max_freq")?.toLongOrNull() ?: return null
|
||||
return (if (min != null) "${mhz(min)}–" else "up to ") + mhz(max)
|
||||
GpuLimits.first(GpuLimits.stepSources())?.mhz?.let { return "${it.first()} MHz–${it.last()} MHz (${it.size} steps)" }
|
||||
val max = GpuLimits.first(GpuLimits.maxSources())?.mhz?.last() ?: return null
|
||||
val min = GpuLimits.first(GpuLimits.minSources())?.mhz?.first()
|
||||
return (if (min != null) "$min MHz–" else "up to ") + "$max MHz"
|
||||
}
|
||||
|
||||
private fun memory(context: Context) = Section("Memory", buildList<Pair<String, String>> {
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package com.droiddeck.launcher.gpu
|
||||
|
||||
import java.io.File
|
||||
|
||||
object GpuLimits {
|
||||
class Found(val path: String, val mhz: List<Long>)
|
||||
|
||||
private const val KGSL = "/sys/class/kgsl/kgsl-3d0"
|
||||
private const val QCOM_GPU = "/sys/kernel/gpu"
|
||||
|
||||
fun stepSources(): List<String> = listOf(
|
||||
"$KGSL/gpu_available_frequencies", "$KGSL/freq_table_mhz", "$KGSL/devfreq/available_frequencies", "$QCOM_GPU/gpu_freq_table",
|
||||
) + devfreq("available_frequencies")
|
||||
|
||||
fun maxSources(): List<String> = listOf(
|
||||
"$KGSL/max_gpuclk", "$KGSL/max_clock_mhz", "$KGSL/devfreq/max_freq", "$QCOM_GPU/gpu_max_clock",
|
||||
) + devfreq("max_freq")
|
||||
|
||||
fun minSources(): List<String> = listOf(
|
||||
"$KGSL/min_clock_mhz", "$KGSL/devfreq/min_freq", "$QCOM_GPU/gpu_min_clock",
|
||||
) + devfreq("min_freq")
|
||||
|
||||
fun first(sources: List<String>): Found? =
|
||||
sources.firstNotNullOfOrNull { path -> read(path).takeIf { it.isNotEmpty() }?.let { Found(path, it) } }
|
||||
|
||||
fun read(path: String): List<Long> = runCatching {
|
||||
Regex("\\d+").findAll(File(path).readText()).map { mhz(it.value.toLong()) }.filter { it > 0 }.distinct().sorted().toList()
|
||||
}.getOrDefault(emptyList())
|
||||
|
||||
fun mhz(raw: Long): Long = when {
|
||||
raw > 10_000_000 -> raw / 1_000_000
|
||||
raw > 10_000 -> raw / 1_000
|
||||
else -> raw
|
||||
}
|
||||
|
||||
private fun devfreq(file: String): List<String> =
|
||||
File("/sys/class/devfreq").listFiles()?.filter { f ->
|
||||
val n = f.name.lowercase()
|
||||
(n.contains("gpu") || n.contains("mali") || n.contains("kgsl-3d")) && listOf("bus", "bw", "memlat").none { n.contains(it) }
|
||||
}?.sortedBy { it.name }?.map { "${it.path}/$file" }.orEmpty()
|
||||
}
|
||||
@@ -46,9 +46,10 @@ object GpuClockPin {
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun sync(context: Context) {
|
||||
if (!live) return
|
||||
if (SessionPrefs.gpuClockPin(context)) hold(context) else if (pinned) clear(context)
|
||||
fun sync(context: Context): String? {
|
||||
if (!live) return null
|
||||
if (!SessionPrefs.gpuClockPin(context) && pinned) clear(context)
|
||||
return hold(context)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
|
||||
@@ -3,6 +3,8 @@ package com.droiddeck.launcher.gpu
|
||||
import android.content.Intent
|
||||
import android.os.BatteryManager
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Rule
|
||||
import org.junit.Test
|
||||
@@ -40,4 +42,68 @@ class ClockLogComponentTest {
|
||||
clocks = ClockLogComponent(log).also { it.attach(context); it.stop(); it.start() }
|
||||
assertTrue(log.readText(), log.length() == 0L)
|
||||
}
|
||||
@Test fun gpuStepsAndCeilingAreParsedAndPrinted() {
|
||||
val table = tmp.newFile("gpu_available_frequencies").apply { writeText("443000000 350000000 285000000 160000000\n") }
|
||||
val ceiling = tmp.newFile("max_gpuclk").apply { writeText("285000000\n") }
|
||||
val floor = tmp.newFile("min_clock_mhz").apply { writeText("160\n") }
|
||||
val clock = tmp.newFile("gpu_clock").apply { writeText("230\n") }
|
||||
val steps = GpuLimits.first(listOf(tmp.root.path + "/missing", table.path))!!
|
||||
assertEquals(listOf(160L, 285L, 350L, 443L), steps.mhz)
|
||||
assertEquals(
|
||||
listOf(
|
||||
"gpu steps: 160 285 350 443 MHz from ${table.path}",
|
||||
"gpu ceiling from: ${ceiling.path}",
|
||||
"gpu floor: 160 MHz from ${floor.path}",
|
||||
),
|
||||
ClockLogComponent.limitLines(steps, ceiling.path, GpuLimits.first(listOf(floor.path))),
|
||||
)
|
||||
assertEquals(" | gpu 230/285(of 443) MHz", ClockLogComponent.gpuField(clock.path, ceiling.path, steps.mhz.last()))
|
||||
ceiling.writeText("443000000\n")
|
||||
assertEquals(" | gpu 230/443 MHz", ClockLogComponent.gpuField(clock.path, ceiling.path, steps.mhz.last()))
|
||||
}
|
||||
|
||||
@Test fun aZeroCeilingIsNotALimit() {
|
||||
val clock = tmp.newFile("gpu_clock").apply { writeText("0\n") }
|
||||
val zero = tmp.newFile("max_gpuclk").apply { writeText("0\n") }
|
||||
assertEquals(" | gpu 0 MHz", ClockLogComponent.gpuField(clock.path, zero.path, 443))
|
||||
assertEquals(listOf("gpu limit ${zero.path}: refused"), ClockLogComponent.probeLines("gpu limit", listOf(zero.path), ClockLogComponent::limit))
|
||||
assertEquals(listOf("gpu source ${clock.path}: readable"), ClockLogComponent.probeLines("gpu source", listOf(clock.path)))
|
||||
assertNull(ClockLogComponent.ceilingSource(listOf(zero.path)))
|
||||
zero.writeText("285000000\n")
|
||||
assertEquals(zero.path, ClockLogComponent.ceilingSource(listOf(zero.path)))
|
||||
assertEquals(" | gpu 0/285(of 443) MHz", ClockLogComponent.gpuField(clock.path, zero.path, 443))
|
||||
}
|
||||
|
||||
@Test fun aStepTableWithALeadingZeroIsReadable() {
|
||||
val steps = tmp.newFile("freq_table_mhz").apply { writeText("0 160000000 285000000\n") }
|
||||
assertEquals(listOf(160L, 285L), GpuLimits.first(listOf(steps.path))?.mhz)
|
||||
assertEquals(listOf("gpu limit ${steps.path}: readable"), ClockLogComponent.probeLines("gpu limit", listOf(steps.path), ClockLogComponent::firstStep))
|
||||
}
|
||||
|
||||
@Test fun unreadableOrMissingLimitsLeaveTheSampleUnchanged() {
|
||||
val clock = tmp.newFile("clock_mhz").apply { writeText("230\n") }
|
||||
val refused = tmp.newFolder("max_clock_mhz")
|
||||
val missing = tmp.root.path + "/gpu_max_clock"
|
||||
assertEquals(" | gpu 230 MHz", ClockLogComponent.gpuField(clock.path, null, null))
|
||||
assertEquals(" | gpu 230 MHz", ClockLogComponent.gpuField(clock.path, missing, 443))
|
||||
assertEquals(" | gpu 230 MHz", ClockLogComponent.gpuField(clock.path, refused.path, 443))
|
||||
assertEquals("", ClockLogComponent.gpuField(null, null, null))
|
||||
assertNull(GpuLimits.first(listOf(missing, refused.path)))
|
||||
assertEquals(listOf("gpu limit ${refused.path}: refused"), ClockLogComponent.probeLines("gpu limit", listOf(missing, refused.path)))
|
||||
assertEquals(
|
||||
listOf("gpu steps: nothing readable", "gpu ceiling from: nothing readable", "gpu floor: nothing readable"),
|
||||
ClockLogComponent.limitLines(null, null, null),
|
||||
)
|
||||
}
|
||||
|
||||
@Test fun aCeilingChangeMidSessionShowsInTheNextSample() {
|
||||
val clock = tmp.newFile("cur_freq").apply { writeText("443000000\n") }
|
||||
val ceiling = tmp.newFile("max_freq").apply { writeText("443000000\n") }
|
||||
val first = ClockLogComponent.gpuField(clock.path, ceiling.path, 443)
|
||||
ceiling.writeText("285000000\n")
|
||||
clock.writeText("285000000\n")
|
||||
val second = ClockLogComponent.gpuField(clock.path, ceiling.path, 443)
|
||||
assertEquals(" | gpu 443/443 MHz", first)
|
||||
assertEquals(" | gpu 285/285(of 443) MHz", second)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package com.droiddeck.launcher.session
|
||||
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], manifest = Config.NONE)
|
||||
class GpuClockPinTest {
|
||||
private val context = RuntimeEnvironment.getApplication()
|
||||
|
||||
@After fun stop() { GpuClockPin.stop(context) }
|
||||
|
||||
@Test fun aToggleOutsideASessionSaysNothing() {
|
||||
SessionPrefs.setGpuClockPin(context, true)
|
||||
assertNull(GpuClockPin.sync(context))
|
||||
}
|
||||
|
||||
@Test fun aToggleMidSessionReportsTheHoldWithTheStartWording() {
|
||||
SessionPrefs.setGpuClockPin(context, false)
|
||||
val started = GpuClockPin.start(context)
|
||||
assertEquals("gpu clock: governed", started)
|
||||
SessionPrefs.setGpuClockPin(context, true)
|
||||
val held = GpuClockPin.sync(context)
|
||||
assertEquals("gpu clock: no /dev/kgsl-3d0, left governed", held)
|
||||
SessionPrefs.setGpuClockPin(context, false)
|
||||
assertEquals(started, GpuClockPin.sync(context))
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user