diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index 06735ead38..b195192643 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -179,6 +179,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet private var syncFallback by mutableStateOf(true) private var fsyncFirst by mutableStateOf(false) private var gamescopeRealtime by mutableStateOf(false) + private var paceCores by mutableStateOf(true) private var ramCapMb by mutableStateOf(0) private var zramClient by mutableStateOf(true) private var vramCapMb by mutableStateOf(0) @@ -2624,7 +2625,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet private fun PerformanceHost() { PerformancePage( cores = CpuCores.all.map { c -> CoreRow(c, "cpu$c" + (CpuCores.maxGhz(c)?.let { String.format(java.util.Locale.US, " · %.1f GHz", it) } ?: "")) }, - clientOverride = clientOverride, clientCores = clientCores, gameCores = gameCores, + clientOverride = clientOverride, clientCores = clientCores, gameCores = gameCores, paceCores = paceCores, tuSysmem = tuSysmem, zinkLazy = zinkLazy, glThread = glThread, noGlError = noGlError, noXalia = noXalia, fastSync = fastSync, syncFallback = syncFallback, @@ -2638,6 +2639,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet prootNoSeccomp = prootNoSeccomp, prootFastPath = prootFastPath, nativeUserland = nativeUserland, cursorComposite = cursorComposite, guestHostname = guestHostname, phantomWarning = phantomWarning, onClientOverride = { on -> SessionPrefs.setClientCpusOverride(this, on); clientOverride = on }, + onPaceCores = { on -> SessionPrefs.setPaceCores(this, on); paceCores = on }, onTuSysmem = { on -> SessionPrefs.setTuSysmem(this, on); tuSysmem = on }, onZinkLazy = { on -> SessionPrefs.setZinkLazy(this, on); zinkLazy = on }, onGlThread = { on -> SessionPrefs.setGlThread(this, on); glThread = on }, @@ -2944,6 +2946,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet syncFallback = SessionPrefs.syncFallback(this) fsyncFirst = SessionPrefs.fsyncFirst(this) gamescopeRealtime = SessionPrefs.gamescopeRealtime(this) + paceCores = SessionPrefs.paceCores(this) ramCapMb = SessionPrefs.ramCapMb(this) zramClient = SessionPrefs.zramClient(this) vramCapMb = SessionPrefs.vramCapMb(this) diff --git a/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt b/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt index 63037a24ac..c6dd49a4c3 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt @@ -274,6 +274,7 @@ object DeviceReport { EsyncPacks.status(LinuxRuntime.rootDir(context)).let { k("droiddeck-esync packs", "${it.installed} installed, ${it.wanted} wanted") } k("Linux x86 (FEX)", if (com.droiddeck.launcher.runtime.LinuxFex.ready(context)) "ready" else "not set up") k("gamescope realtime", SessionPrefs.gamescopeRealtime(context)) + k("pace cores", SessionPrefs.paceCores(context)) k("zRAM: compress Steam during games", SessionPrefs.zramClient(context)) k("RAM cap", SessionPrefs.ramCapMb(context).let { if (it > 0) "$it MB" else "off" }) k("VRAM cap", SessionPrefs.vramCapMb(context).let { if (it > 0) "$it MB" else "driver default" }) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 13348cef74..9d179cefd9 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -104,6 +104,7 @@ object SessionFiles { "usr/local/bin/droiddeck-steam-share" to "usr/local/bin/droiddeck-steam-share", "usr/local/bin/droiddeck-seed-redists" to "usr/local/bin/droiddeck-seed-redists", "usr/local/bin/droiddeck-launcher-cores" to "usr/local/bin/droiddeck-launcher-cores", + "usr/local/bin/droiddeck-pace-cores" to "usr/local/bin/droiddeck-pace-cores", "usr/local/bin/droiddeck-proton-extra" to "usr/local/bin/droiddeck-proton-extra", "usr/local/bin/droiddeck-netmanager" to "usr/local/bin/droiddeck-netmanager", "usr/local/bin/droiddeck-login1" to "usr/local/bin/droiddeck-login1", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index faf6a6674f..ae64425b77 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -750,6 +750,12 @@ object SessionPrefs { prefs(context).edit().putBoolean("syncFallback", on).apply() } + fun paceCores(context: Context): Boolean = prefs(context).getBoolean("paceCores", true) + + fun setPaceCores(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("paceCores", on).apply() + } + fun gamescopeRealtime(context: Context): Boolean = prefs(context).getBoolean("gamescopeRealtime", false) fun setGamescopeRealtime(context: Context, on: Boolean) { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 3e7f30b15f..6613319033 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -985,6 +985,7 @@ class SessionService : Service() { guest.add("BL_SYNC=" + (if (SessionPrefs.fastSync(this)) "1" else "0")) guest.add("BL_SYNC_FALLBACK=" + (if (SessionPrefs.syncFallback(this)) "1" else "0")) guest.add("BL_FSYNC_FIRST=" + (if (SessionPrefs.fsyncFirst(this)) "1" else "0")) + guest.add("BL_PACE_CORES=" + (if (SessionPrefs.paceCores(this)) "1" else "0")) guest.add("BL_GAMESCOPE_REALTIME=" + (if (SessionPrefs.gamescopeRealtime(this)) "1" else "0")) if (SessionPrefs.cursorComposite(this)) guest.add("BL_CURSOR_COMPOSITE=1") relativeMouseForSession().takeIf { it != 0 }?.let { guest.add("gamescope_relative_mouse=$it") } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt index 2c600dafee..17696c44a3 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt @@ -20,7 +20,7 @@ object SettingsReset { "gamepadLeft", "gamepadRight", "pipAutoEnter", "unfoldedControls", "unfoldedControlsWithController", "stretch16x9", "picturePosition", "railLabels", "agentTab", "navTabOrder", "navTabShelved", "navTabHidden", "pcKeyboardSize", "pcKeyboardOpacity", "pcKeyboardHiddenKeys", "gpuDriverMode", "androidDriver", "linuxDriver", "linuxDriver.steam", "linuxDriver.desktop", - "tuSysmem", "glThread", "noGlError", "zinkLazy", "mangoapp", "gpuClockPin", "gamescopeRealtime", "ramCapMb", "vramCapMb", "zramClient", + "tuSysmem", "glThread", "noGlError", "zinkLazy", "mangoapp", "gpuClockPin", "gamescopeRealtime", "paceCores", "ramCapMb", "vramCapMb", "zramClient", "directAudio", "mic", "wifiDiscovery", "clientCpusOverride", "clientCpus", "gameCpus", "noXalia", "fastSync", "fsyncFirst", "syncFallback", "prootNoSeccomp", "prootFastPath", "nativeUserland", "cursorComposite", "guestHostname", "fexPreset", "forceSsbs", "logs", "gameDebugLogsEnabled", "enhancedDiagnosticsNext", "storageDiagnostics", "buildWatermark", diff --git a/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt index f8f44907a7..fdfd5ca3d2 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt @@ -36,6 +36,7 @@ fun PerformancePage( clientOverride: Boolean, clientCores: Set, gameCores: Set, + paceCores: Boolean, tuSysmem: Boolean, zinkLazy: Boolean, glThread: Boolean, @@ -58,6 +59,7 @@ fun PerformancePage( guestHostname: String, phantomWarning: String?, onClientOverride: (Boolean) -> Unit, + onPaceCores: (Boolean) -> Unit, onTuSysmem: (Boolean) -> Unit, onZinkLazy: (Boolean) -> Unit, onGlThread: (Boolean) -> Unit, @@ -105,6 +107,11 @@ fun PerformancePage( stringResource(R.string.perf_game_cores_hint), coreItems, gameCores, onToggle = onGameCore, ) + ToggleRow( + host, "paceCores", stringResource(R.string.perf_pace_cores), + stringResource(R.string.perf_pace_cores_hint), + paceCores, onChange = onPaceCores, + ) } SettingsGroup(stringResource(R.string.perf_client_ui)) { ToggleRow( diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 1dcf934d12..8e447bf260 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -576,6 +576,8 @@ أنوية الألعاب أنوية الألعاب الأنوية المخصّصة للألعاب. عند تحديدها جميعًا، يوزّع Android المهام بحرية. + توفير الطاقة في الألعاب الثابتة + يشغّل اللعبة على الأنوية الأبطأ ما دامت تحافظ على معدل إطارات ثابت، ويعيدها إلى أنويتها المعتادة عندما تتأخر. واجهة العميل GL متعدد مؤشرات الترابط قد يجعل قوائم Steam أسرع استجابة. diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index cc5f0780fb..24ea2b1422 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -570,6 +570,8 @@ Núcleos de juegos Núcleos de juegos Núcleos para los juegos. Con todos seleccionados, Android los asigna libremente. + Ahorrar energía en juegos estables + Ejecuta un juego en los núcleos más lentos mientras mantiene una tasa de fotogramas estable, y lo devuelve a sus núcleos habituales cuando se queda atrás. Interfaz del cliente GL con subprocesos Puede hacer los menús de Steam más ágiles. diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index dad41a96ac..22fc348301 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -568,6 +568,8 @@ Ядра за игри Ядра за игри Ядра за игри. Когато всички са избрани, Android ги разпределя свободно. + Пестене на енергия при стабилни игри + Пуска играта на по-бавните ядра, докато държи стабилна кадрова честота, и я връща на обичайните ѝ ядра, щом изостане. Интерфейс на клиента Многонишков GL Може да направи менютата на Steam по-отзивчиви. diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 6fab61abc0..63608182bd 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -572,6 +572,8 @@ Jádra pro hru Jádra pro hru Jádra pro hry. Se všemi vybranými plánuje Android volně. + Šetřit energii u stabilních her + Spouští hru na pomalejších jádrech, dokud drží stabilní snímkovou frekvenci, a vrátí ji na obvyklá jádra, jakmile začne zaostávat. Rozhraní klienta Vícevláknové GL Může zrychlit odezvu nabídek Steamu. diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index d124460541..7ce9bb32f0 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -568,6 +568,8 @@ Spilkerner Spilkerner Kerner til spil. Med alle valgt planlægger Android frit. + Spar strøm i stabile spil + Kører et spil på de langsommere kerner, mens det holder en stabil billedfrekvens, og flytter det tilbage til sine vante kerner, når det halter bagefter. Klientgrænseflade Threaded GL Kan gøre Steam-menuer mere lydhøre. diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index d90b549827..d5fe280ca9 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -568,6 +568,8 @@ Spielkerne Spielkerne Kerne für Spiele. Sind alle ausgewählt, verteilt Android frei. + Strom sparen bei stabilen Spielen + Lässt ein Spiel auf den langsameren Kernen laufen, solange es eine stabile Bildrate hält, und gibt ihm seine üblichen Kerne zurück, sobald es zurückfällt. Client-Oberfläche Threaded GL Kann Steam-Menüs reaktionsschneller machen. diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index ed829530da..c41a86e35d 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -568,6 +568,8 @@ Πυρήνες παιχνιδιού Πυρήνες παιχνιδιού Πυρήνες για παιχνίδια. Με όλους επιλεγμένους, το Android τους προγραμματίζει ελεύθερα. + Εξοικονόμηση ενέργειας σε σταθερά παιχνίδια + Τρέχει το παιχνίδι στους πιο αργούς πυρήνες όσο κρατά σταθερό ρυθμό καρέ, και το επιστρέφει στους συνήθεις πυρήνες του όταν μένει πίσω. Διεπαφή πελάτη Νηματοποιημένο GL Μπορεί να κάνει τα μενού του Steam πιο αποκρίσιμα. diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 77899d06a2..9791e456a2 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -570,6 +570,8 @@ Núcleos de juegos Núcleos de juegos Núcleos para los juegos. Con todos seleccionados, Android los asigna libremente. + Ahorrar energía en juegos estables + Ejecuta un juego en los núcleos más lentos mientras mantiene una tasa de fotogramas estable, y lo devuelve a sus núcleos habituales cuando se queda atrás. Interfaz del cliente GL con subprocesos Puede hacer los menús de Steam más ágiles. diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 40e762bde1..81ba87e48f 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -568,6 +568,8 @@ Pelin ytimet Pelin ytimet Ytimet peleille. Kun kaikki on valittuna, Android ajoittaa vapaasti. + Säästä virtaa tasaisissa peleissä + Ajaa pelin hitaammilla ytimillä, kun se pitää tasaisen ruudunpäivitysnopeuden, ja palauttaa sen tavallisille ytimilleen, kun se jää jälkeen. Asiakasohjelman käyttöliittymä Säikeistetty GL Voi tehdä Steamin valikoista reagoivampia. diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 9883772cf6..61add42185 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -570,6 +570,8 @@ Cœurs de jeu Cœurs de jeu Cœurs utilisés par les jeux. Si tous sont sélectionnés, Android planifie librement. + Économiser l\'énergie dans les jeux stables + Fait tourner un jeu sur les cœurs plus lents tant qu\'il tient une fréquence d\'images stable, et le remet sur ses cœurs habituels dès qu\'il prend du retard. Interface du client Multithread GL Peut rendre les menus Steam plus réactifs. diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index e5a3ae56f8..3984c5ebcf 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -568,6 +568,8 @@ गेम कोर गेम कोर गेम के लिए कोर। सभी चुने होने पर, Android खुद शेड्यूल करता है। + स्थिर गेम में बिजली बचाएँ + जब तक गेम स्थिर फ़्रेम रेट बनाए रखता है, उसे धीमे कोर पर चलाता है, और पिछड़ते ही उसके सामान्य कोर पर लौटा देता है। क्लाइंट इंटरफ़ेस थ्रेडेड GL Steam मेनू को ज़्यादा रिस्पॉन्सिव बना सकता है। diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index 0d568a2536..642c55099a 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -568,6 +568,8 @@ Játékmagok Játékmagok Magok a játékokhoz. Ha mind kiválasztva van, az Android szabadon ütemez. + Energiatakarékosság stabil játékoknál + A játékot a lassabb magokon futtatja, amíg stabil képkockasebességet tart, és visszaadja a szokásos magjait, amint lemarad. Kliens felhasználói felület Szálalt GL Reszponzívabbá teheti a Steam menüit. diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 2ea5450c1d..7995aec302 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -566,6 +566,8 @@ Core gim Core gim Core untuk gim. Dengan semua dipilih, Android menjadwalkan secara bebas. + Hemat daya pada game yang stabil + Menjalankan game di core yang lebih lambat selama frame rate-nya stabil, dan mengembalikannya ke core biasanya begitu tertinggal. Antarmuka klien GL berulir (threaded) Dapat membuat menu Steam lebih responsif. diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 7d7b096e2a..b4f510ad7e 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -570,6 +570,8 @@ Core dei giochi Core dei giochi Core per i giochi. Con tutti selezionati, Android li gestisce liberamente. + Risparmia energia nei giochi stabili + Esegue un gioco sui core più lenti finché mantiene un frame rate stabile, e lo riporta sui suoi core abituali appena resta indietro. Interfaccia del client GL multithread Può rendere più reattivi i menu di Steam. diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index a289e0dbed..ff21b89acf 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -566,6 +566,8 @@ ゲームコア ゲームコア ゲームが使用するコア。すべて選択するとAndroidが自由にスケジュールします。 + 安定したゲームで省電力 + フレームレートが安定している間はゲームを低速コアで動かし、遅れ始めたら元のコアに戻します。 クライアントUI GLマルチスレッド Steamメニューの応答が速くなる可能性があります。 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 82fcb4bb83..da130bf356 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -566,6 +566,8 @@ 게임 코어 게임 코어 게임에서 사용하는 코어입니다. 모두 선택하면 Android가 자유롭게 스케줄링합니다. + 안정적인 게임에서 전력 절약 + 게임이 안정적인 프레임 레이트를 유지하는 동안 느린 코어에서 실행하고, 뒤처지면 원래 코어로 되돌립니다. 클라이언트 UI GL 멀티스레딩 Steam 메뉴 응답 속도를 높일 수 있습니다. diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index bdb95e029c..199a9e216e 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -566,6 +566,8 @@ Teras permainan Teras permainan Teras untuk permainan. Dengan semua dipilih, Android menjadualkan secara bebas. + Jimat kuasa dalam permainan yang stabil + Menjalankan permainan pada teras yang lebih perlahan selagi kadar bingkainya stabil, dan mengembalikannya ke teras biasanya sebaik ia ketinggalan. Antara muka klien GL berbenang Boleh menjadikan menu Steam lebih responsif. diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index dbe9e0626d..2402ebbd7a 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -568,6 +568,8 @@ Spillkjerner Spillkjerner Kjerner for spill. Med alle valgt, planlegger Android fritt. + Spar strøm i stabile spill + Kjører et spill på de tregere kjernene mens det holder en stabil bildefrekvens, og flytter det tilbake til de vanlige kjernene når det henger etter. Klientgrensesnitt Trådet GL Kan gjøre Steam-menyer mer responsive. diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index eb9cb76b8b..850d2710b0 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -568,6 +568,8 @@ Gamecores Gamecores Cores voor games. Met alles geselecteerd verdeelt Android vrij. + Stroom besparen bij stabiele games + Draait een game op de tragere kernen zolang de framerate stabiel blijft, en zet hem terug op zijn gebruikelijke kernen zodra hij achterraakt. Clientinterface GL-threading Kan Steam-menu’s sneller laten reageren. diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 845213c387..0ef2c93915 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -572,6 +572,8 @@ Rdzenie gier Rdzenie gier Rdzenie dla gier. Gdy wszystkie są zaznaczone, Android swobodnie przydziela zadania. + Oszczędzaj energię w stabilnych grach + Uruchamia grę na wolniejszych rdzeniach, dopóki utrzymuje stabilną liczbę klatek, a gdy zaczyna nie nadążać, przywraca jej zwykłe rdzenie. Interfejs klienta Wielowątkowy GL Może poprawić responsywność menu Steam. diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index d55c2d3a0b..8d0551a995 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -570,6 +570,8 @@ Núcleos dos jogos Núcleos dos jogos Núcleos para os jogos. Com todos selecionados, o Android distribui livremente. + Poupar energia em jogos estáveis + Executa um jogo nos núcleos mais lentos enquanto mantém uma taxa de fotogramas estável, e devolve-o aos núcleos habituais quando fica para trás. Interface do cliente GL multithread Pode fazer os menus do Steam responder mais depressa. diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 3ae6fd2f50..43c698f03a 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -570,6 +570,8 @@ Núcleos dos jogos Núcleos dos jogos Núcleos para os jogos. Com todos selecionados, o Android distribui livremente. + Economizar energia em jogos estáveis + Executa um jogo nos núcleos mais lentos enquanto mantém uma taxa de quadros estável, e o devolve aos núcleos de sempre quando fica para trás. Interface do cliente GL em threads Pode deixar os menus da Steam mais responsivos. diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 27641656a9..c8b190e4e7 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -570,6 +570,8 @@ Nuclee pentru joc Nuclee pentru joc Nuclee pentru jocuri. Cu toate selectate, Android le programează liber. + Economisește energie în jocurile stabile + Rulează jocul pe nucleele mai lente cât timp își menține o rată de cadre stabilă și îl readuce pe nucleele obișnuite când rămâne în urmă. Interfața clientului GL pe fire Poate face meniurile Steam mai receptive. diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index a99f40c703..36d59e8f9e 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -591,6 +591,8 @@ Ядра игры Ядра игры Ядра, используемые играми. При выборе всех ядер Android планирует свободно. + Экономить энергию в стабильных играх + Запускает игру на более медленных ядрах, пока она держит стабильную частоту кадров, и возвращает её на обычные ядра, как только она отстаёт. Интерфейс клиента Многопоточность GL Может ускорить отклик меню Steam. diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index d686c8693a..68747edf73 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -568,6 +568,8 @@ Spelkärnor Spelkärnor Kärnor för spel. Med alla valda schemalägger Android fritt. + Spara ström i stabila spel + Kör ett spel på de långsammare kärnorna medan det håller en stabil bildfrekvens, och flyttar tillbaka det till sina vanliga kärnor när det halkar efter. Klientgränssnitt Trådad GL Kan göra Steams menyer mer responsiva. diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index 596678df67..1ceee97401 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -566,6 +566,8 @@ คอร์สำหรับเกม คอร์เกม คอร์สำหรับเกม เมื่อเลือกทั้งหมด Android จะจัดสรรได้อย่างอิสระ + ประหยัดพลังงานในเกมที่นิ่ง + รันเกมบนคอร์ที่ช้ากว่าขณะที่เฟรมเรตคงที่ และย้ายกลับไปยังคอร์ปกติทันทีที่ตามไม่ทัน อินเทอร์เฟซไคลเอนต์ GL แบบเธรด อาจทำให้เมนู Steam ตอบสนองไวขึ้น diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 7b6e1553a1..ed4f94f76e 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -568,6 +568,8 @@ Oyun çekirdekleri Oyun çekirdekleri Oyunlar için çekirdekler. Tümü seçiliyse Android serbestçe zamanlar. + Kararlı oyunlarda güç tasarrufu + Oyun kare hızını sabit tutarken onu yavaş çekirdeklerde çalıştırır, geride kalınca her zamanki çekirdeklerine geri döndürür. İstemci arayüzü İş parçacıklı GL Steam menülerinin daha hızlı tepki vermesini sağlayabilir. diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 2afbe7c796..1ad105a297 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -572,6 +572,8 @@ Ядра для ігор Ядра для ігор Ядра для ігор. Якщо вибрано всі, Android розподіляє навантаження вільно. + Заощаджувати енергію в стабільних іграх + Запускає гру на повільніших ядрах, поки вона тримає стабільну частоту кадрів, і повертає її на звичні ядра, щойно вона відстає. Інтерфейс клієнта Багатопотоковий GL Меню Steam можуть реагувати швидше. diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index ea76ef9bc6..ab2a98ce24 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -566,6 +566,8 @@ Lõi game Lõi game Lõi dành cho game. Khi chọn tất cả, Android tự do lập lịch. + Tiết kiệm pin với game ổn định + Chạy game trên các nhân chậm hơn khi game giữ tốc độ khung hình ổn định, và đưa game về các nhân thường dùng khi bị tụt lại. Giao diện client GL đa luồng Có thể giúp menu Steam phản hồi nhanh hơn. diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index b84c613839..4bd469ad4f 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -566,6 +566,8 @@ 游戏核心 游戏核心 分配给游戏的核心。全选时由 Android 自由调度。 + 稳定的游戏省电运行 + 游戏帧率稳定时在较慢的核心上运行,一旦跟不上就回到原来的核心。 客户端界面 线程化 GL 可能让 Steam 菜单更流畅。 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index c8828521e1..91ad629e73 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -566,6 +566,8 @@ 遊戲核心 遊戲核心 供遊戲使用的核心。全選時由 Android 自由排程。 + 穩定的遊戲省電運行 + 遊戲幀率穩定時在較慢的核心上運行,一旦跟不上就回到原來的核心。 用戶端介面 GL 多線程 可能讓 Steam 選單反應更快。 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 5cacb7ee87..53f9257b2d 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -566,6 +566,8 @@ 遊戲核心 遊戲核心 供遊戲使用的核心。全選時由 Android 自由排程。 + 穩定的遊戲省電執行 + 遊戲影格率穩定時在較慢的核心上執行,一旦跟不上就回到原本的核心。 用戶端介面 GL 多執行緒 可能讓 Steam 選單回應更快。 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 160c1290dd..5b0bef4927 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -616,6 +616,8 @@ Game cores Game cores Cores for games. With all selected, Android schedules freely. + Save power on steady games + Runs a game on the slower cores while it holds a steady frame rate, and back on its usual cores once it falls behind. Client interface Threaded GL May make Steam menus more responsive. diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-pace-cores b/tools/linuxfs/overlay/usr/local/bin/droiddeck-pace-cores new file mode 100755 index 0000000000..0b1c62f7c9 --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-pace-cores @@ -0,0 +1,266 @@ +#!/usr/bin/python3 +import os +import signal +import struct +import sys +import time +from pathlib import Path + +MAGIC = 0x46484444 +HEADER = 128 +POLL = 0.5 +SETTLE = 3.0 +WINDOW = 1.0 +LATE = 1.5 +PACED_LATE_SHARE = 0.02 +RELEASE_LATE_SHARE = 0.05 +SLOWER = 1.04 +MAX_INTERVAL = 1e9 / 30 +SPREAD = 0.08 +BACKOFF = 30.0 +BACKOFF_MAX = 600.0 + + +def log(message): + print("droiddeck-pace-cores: " + message, flush=True) + + +def parse_cores(text): + cores = set() + for part in text.strip().split(","): + if not part: + continue + first, _, last = part.partition("-") + cores.update(range(int(first), int(last or first) + 1)) + return cores + + +def efficient_cores(cpu=Path("/sys/devices/system/cpu"), own=None): + try: + online = parse_cores((cpu / "online").read_text()) + except (OSError, ValueError): + online = set(range(os.cpu_count() or 0)) + online &= own if own is not None else os.sched_getaffinity(0) + for name in ("cpu_capacity", "cpufreq/cpuinfo_max_freq"): + try: + speed = {core: int((cpu / f"cpu{core}/{name}").read_text()) for core in online} + except (OSError, ValueError): + continue + top = max(speed.values(), default=0) + return {core for core, value in speed.items() if value < top} + return set() + + +class Frames: + """gamescope's per-frame feed for the HUD: frame intervals of the focused app, its pid and whether Steam is in front.""" + + def __init__(self, path): + self.path = Path(path) + self.count = None + + def read(self): + try: + data = self.path.read_bytes() + except OSError: + return None + if len(data) < HEADER or struct.unpack_from(" LATE * period) / len(intervals) + + +def paced_interval(intervals): + """The interval of a game a cap holds at 30 fps or more; a starved or uncapped game spreads.""" + if len(intervals) < 2: + return None + ordered = sorted(intervals) + held = ordered[len(ordered) // 2] + if held > 1.04 * MAX_INTERVAL: + return None + if ordered[len(ordered) // 10] < (1 - SPREAD) * held or ordered[len(ordered) * 9 // 10] > (1 + SPREAD) * held: + return None + if late_share(intervals, held) > PACED_LATE_SHARE: + return None + return held + + +class Cores: + + def get(self, tid): + return os.sched_getaffinity(tid) + + def set(self, tid, cpus): + os.sched_setaffinity(tid, cpus) + + +class Parker: + """Keeps one process's threads off the fastest cores and puts back what each had.""" + + def __init__(self, efficient, proc=Path("/proc"), cores=None): + self.efficient = efficient + self.proc = proc + self.cores = cores or Cores() + self.pid = None + self.before = {} + self.present = None + self.own = set() + + def tasks(self, pid): + try: + return [int(tid) for tid in os.listdir(self.proc / str(pid) / "task") if tid.isdigit()] + except OSError: + return [] + + def park(self, pid): + self.pid = pid + tids = self.tasks(pid) + if self.present is None: + self.present = set(tids) + masks = {} + for tid in tids: + if tid not in self.before: + try: + masks[tid] = self.cores.get(tid) + except OSError: + continue + # A mask the game gave one of its own threads may be passed on by it, not by a parked thread. + self.own.update(frozenset(now) for tid, now in masks.items() if tid in self.present) + inherited = {} + for before, parked in self.before.values(): + inherited[frozenset(parked)] = inherited.get(frozenset(parked), set()) | before + for tid, now in masks.items(): + try: + wanted = now & self.efficient + if wanted and wanted != now: + self.cores.set(tid, wanted) + self.before[tid] = (now, wanted) + elif tid not in self.present and frozenset(now) in inherited and frozenset(now) not in self.own: + self.before[tid] = (inherited[frozenset(now)], now) + except OSError: + continue + + def release(self): + for tid, (before, parked) in self.before.items(): + try: + if self.cores.get(tid) == parked: + self.cores.set(tid, before) + except OSError: + continue + self.pid = None + self.present = None + self.own.clear() + self.before.clear() + + +class Governor: + def __init__(self, frames, parker, clock=time.monotonic): + self.frames = frames + self.parker = parker + self.clock = clock + self.pid = None + self.window = [] + self.since = None + self.held = None + self.blocked = {} + + def tick(self): + read = self.frames.read() + if read is None: + return + pid, steam, intervals = read + now = self.clock() + if steam or not pid or pid != self.pid: + if self.parker.pid is not None: + self.release(now, "focus left the game", backoff=False) + self.pid = None if steam else pid + self.window, self.since = [], now + return + self.window.extend((now, value) for value in intervals) + if self.parker.pid is None and not intervals: + self.window, self.since = [], now + return + if self.parker.pid is None: + self.consider(now) + else: + self.watch(now) + + def consider(self, now): + self.window = [entry for entry in self.window if entry[0] >= now - SETTLE] + if now - self.since < SETTLE or now < self.blocked.get(self.pid, (0, 0))[0]: + return + intervals = [value for _, value in self.window] + if sum(intervals) < 0.9 * SETTLE * 1e9: + return + held = paced_interval(intervals) + if held is None: + return + self.held = held + self.parker.park(self.pid) + if self.parker.before: + self.window = [] + self.since = now + log(f"pid {self.pid} holds {1e9 / held:.0f} fps, {len(self.parker.before)} thread(s) off the fastest cores") + else: + self.parker.release() + + def watch(self, now): + self.parker.park(self.pid) + self.window = [entry for entry in self.window if entry[0] >= now - WINDOW] + intervals = [value for _, value in self.window] + if now - self.since < WINDOW: + return + if len(intervals) < 0.5 * WINDOW * 1e9 / self.held: + self.release(now, "frames stalled") + return + if late_share(intervals, self.held) > RELEASE_LATE_SHARE or median(intervals) > SLOWER * self.held: + self.release(now, "frames fell behind") + + def release(self, now, why, backoff=True): + pid = self.parker.pid + self.parker.release() + if backoff: + _, wait = self.blocked.get(pid, (0, BACKOFF / 2)) + wait = min(wait * 2, BACKOFF_MAX) + self.blocked[pid] = (now + wait, wait) + log(f"pid {pid} back on every core: {why}; not again for {wait:.0f} s") + else: + log(f"pid {pid} back on every core: {why}") + self.window, self.since = [], now + + def stop(self, *_): + self.parker.release() + sys.exit(0) + + +def main(argv): + if len(argv) != 1: + print("usage: droiddeck-pace-cores ", file=sys.stderr) + return 2 + efficient = efficient_cores() + if not efficient: + return 0 + governor = Governor(Frames(argv[0]), Parker(efficient)) + for sig in (signal.SIGTERM, signal.SIGHUP, signal.SIGINT): + signal.signal(sig, governor.stop) + while True: + governor.tick() + time.sleep(POLL) + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index bbfe862b1d..90bd191b4d 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -1183,6 +1183,10 @@ case $mode in && [ "${BL_STEAM_UI:-}" != desktop ] && [ -x /usr/local/bin/droiddeck-launcher-cores ]; then /usr/local/bin/droiddeck-launcher-cores "$BL_LAUNCH_DIR/agent/focus.json" 2>&1 & fi + if [ "${BL_PACE_CORES:-1}" != 0 ] && [ -n "${DROIDDECK_HUD_FRAMES:-}" ] && [ -z "${BL_DESKTOP:-}" ] \ + && [ -x /usr/local/bin/droiddeck-pace-cores ]; then + /usr/local/bin/droiddeck-pace-cores "$DROIDDECK_HUD_FRAMES" 2>&1 & + fi if [ "$steam_x64" = 0 ]; then step "registering the app's game library with Steam" diff --git a/tools/tests/test_pace_cores.py b/tools/tests/test_pace_cores.py new file mode 100644 index 0000000000..564edb24be --- /dev/null +++ b/tools/tests/test_pace_cores.py @@ -0,0 +1,241 @@ +from pathlib import Path +import runpy +import struct +import tempfile +import unittest + + +BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin' +MODULE = runpy.run_path(str(BIN / 'droiddeck-pace-cores')) +Frames = MODULE['Frames'] +Parker = MODULE['Parker'] +Governor = MODULE['Governor'] +efficient_cores = MODULE['efficient_cores'] +paced_interval = MODULE['paced_interval'] + +ALL = set(range(8)) +EFFICIENT = set(range(6)) +VBLANK = 1e9 / 60 +CAPACITY = 1024 + + +class FakeCores: + + def __init__(self, tids): + self.state = {tid: set(ALL) for tid in tids} + + def get(self, tid): + if tid not in self.state: + raise ProcessLookupError(tid) + return set(self.state[tid]) + + def set(self, tid, cpus): + if tid not in self.state: + raise ProcessLookupError(tid) + self.state[tid] = set(cpus) + + +class FeedWriter: + + def __init__(self, path): + self.path = path + self.count = 0 + self.data = bytearray(128 + CAPACITY * 16) + struct.pack_into('= 6 else '792\n') + self.assertEqual(efficient_cores(cpu, set(ALL)), EFFICIENT) + self.assertEqual(efficient_cores(cpu, {6, 7}), set()) + + def test_one_tier_has_none(self): + with tempfile.TemporaryDirectory() as temp: + cpu = Path(temp) + (cpu / 'online').write_text('0-3\n') + for core in range(4): + (cpu / f'cpu{core}').mkdir() + (cpu / f'cpu{core}/cpu_capacity').write_text('1024\n') + self.assertEqual(efficient_cores(cpu, set(range(4))), set()) + + +class GovernorTest(unittest.TestCase): + PID = 400 + TIDS = (400, 401, 402) + + def setUp(self): + temp = tempfile.TemporaryDirectory() + self.addCleanup(temp.cleanup) + root = Path(temp.name) + for tid in self.TIDS: + (root / f'proc/{self.PID}/task/{tid}').mkdir(parents=True) + self.cores = FakeCores(self.TIDS) + self.feed = FeedWriter(root / 'frames') + self.feed.focus(self.PID) + self.now = 0.0 + self.governor = Governor(Frames(root / 'frames'), Parker(EFFICIENT, root / 'proc', self.cores), + clock=lambda: self.now) + self.governor.tick() + + def run_for(self, seconds, interval): + for _ in range(int(seconds / 0.5)): + self.now += 0.5 + self.feed.frames(*([interval] * int(0.5e9 / interval))) + self.governor.tick() + + def test_parks_a_game_that_holds_its_pace(self): + self.run_for(4, VBLANK) + self.assertEqual(self.governor.parker.pid, self.PID) + self.assertTrue(all(cpus == EFFICIENT for cpus in self.cores.state.values())) + + def test_releases_when_frames_fall_behind_and_backs_off(self): + self.run_for(4, VBLANK) + self.run_for(2, 2 * VBLANK) + self.assertIsNone(self.governor.parker.pid) + self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values())) + self.run_for(10, VBLANK) + self.assertIsNone(self.governor.parker.pid) + self.run_for(30, VBLANK) + self.assertEqual(self.governor.parker.pid, self.PID) + + def test_struggling_game_stays_on_every_core(self): + for step in range(20): + self.now += 0.5 + self.feed.frames(*([VBLANK, 2 * VBLANK] * 10)) + self.governor.tick() + self.assertIsNone(self.governor.parker.pid) + self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values())) + + def test_steam_in_front_releases_without_backoff(self): + self.run_for(4, VBLANK) + self.feed.focus(self.PID, steam=True) + self.now += 0.5 + self.governor.tick() + self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values())) + self.feed.focus(self.PID) + self.run_for(4, VBLANK) + self.assertEqual(self.governor.parker.pid, self.PID) + + def test_a_mask_the_game_set_itself_is_kept(self): + self.run_for(4, VBLANK) + self.cores.state[401] = {7} + self.run_for(2, 2 * VBLANK) + self.assertEqual(self.cores.state[401], {7}) + self.assertEqual(self.cores.state[400], ALL) + + def idle_for(self, seconds): + for _ in range(int(seconds / 0.5)): + self.now += 0.5 + self.governor.tick() + + def test_thread_born_parked_is_restored(self): + self.run_for(4, VBLANK) + (self.governor.parker.proc / f'{self.PID}/task/403').mkdir() + self.cores.state[403] = set(EFFICIENT) + self.run_for(1, VBLANK) + self.run_for(2, 2 * VBLANK) + self.assertEqual(self.cores.state[403], ALL) + + def test_a_thread_already_on_efficient_cores_keeps_its_mask(self): + self.cores.state[402] = set(EFFICIENT) + self.run_for(4, VBLANK) + self.run_for(1, VBLANK) + self.run_for(2, 2 * VBLANK) + self.assertEqual(self.cores.state[402], EFFICIENT) + self.assertEqual(self.cores.state[400], ALL) + + def test_a_child_of_a_game_pinned_thread_keeps_its_mask(self): + self.cores.state[402] = set(EFFICIENT) + self.run_for(4, VBLANK) + (self.governor.parker.proc / f'{self.PID}/task/404').mkdir() + self.cores.state[404] = set(EFFICIENT) + self.run_for(1, VBLANK) + self.run_for(2, 2 * VBLANK) + self.assertEqual(self.cores.state[404], EFFICIENT) + self.assertEqual(self.cores.state[400], ALL) + + def test_a_child_of_a_game_pinned_thread_that_exited_keeps_its_mask(self): + self.cores.state[402] = set(EFFICIENT) + self.run_for(4, VBLANK) + (self.governor.parker.proc / f'{self.PID}/task/402').rmdir() + del self.cores.state[402] + (self.governor.parker.proc / f'{self.PID}/task/404').mkdir() + self.cores.state[404] = set(EFFICIENT) + self.run_for(1, VBLANK) + self.run_for(2, 2 * VBLANK) + self.assertEqual(self.cores.state[404], EFFICIENT) + self.assertEqual(self.cores.state[400], ALL) + + def test_born_parked_thread_gets_every_original_it_could_have_had(self): + for tid in self.TIDS: + self.cores.state[tid] = EFFICIENT | {6} + self.cores.state[402] = EFFICIENT | {7} + self.run_for(4, VBLANK) + (self.governor.parker.proc / f'{self.PID}/task/404').mkdir() + self.cores.state[404] = set(EFFICIENT) + self.run_for(1, VBLANK) + self.run_for(2, 2 * VBLANK) + self.assertEqual(self.cores.state[404], ALL) + self.assertEqual(self.cores.state[402], EFFICIENT | {7}) + + def test_a_stalled_game_is_not_parked_on_old_frames(self): + self.run_for(0.5, VBLANK) + self.idle_for(3) + self.assertIsNone(self.governor.parker.pid) + self.run_for(2, VBLANK) + self.assertIsNone(self.governor.parker.pid) + + def test_a_parked_game_that_stops_presenting_is_released(self): + self.run_for(4, VBLANK) + self.run_for(1, 1e9) + self.idle_for(1) + self.assertIsNone(self.governor.parker.pid) + self.assertTrue(all(cpus == ALL for cpus in self.cores.state.values())) + + def test_threads_pinned_to_fast_cores_are_left_alone(self): + self.cores.state[402] = {6, 7} + self.run_for(4, VBLANK) + self.assertEqual(self.cores.state[402], {6, 7}) + self.assertEqual(self.cores.state[400], EFFICIENT) + + +if __name__ == '__main__': + unittest.main()