Programmier-Idee/Teamwork: "split-that-game"

[theSplit]

Hallo,

wie ihr vielleicht mitbekommen habt, haben wir in der Vergangenheit über mögliche Projekte für die NGB.to-Programmierer gesprochen. Da sich aber keine Aufgabe klar durchgesetzt hat - hier ein Vorschlag der letztlich diskutiert wurde.

Update: Wir haben nun ein Repository auf Github, Danke drfuture!

Dieses findet sich hier:
https://github.com/NGB-to/split-that-game

split-that-game

Idee und Hintergrund

Die Grundidee ist einfach: Spiele oder Anwendungen zu splitten bzw. aufzuteilen und höchstmögliche Performance versus Speichernutzung zu erreichen.

Heißt, auf SSD/M.2 SSD Medien Platz zu sparen und auf normalen HDDs nicht so häufig genutze Daten auszulagern, welche nicht kritisch für die Performance von Spielen oder Anwendungen sind - aber viel Platz einnehmen würden.

Um dieses Ziel zu erreichen, sollen Junctions in Windows bzw. Symlinks unter Linux verwendet werden. Profile sollen diesen Prozess, mit vorher definierten Regeln, vereinfachen.

Und eine Onlineschnittstelle durch eine Community unterstützt könnte Profile bzw. Presets für Spiele und Anwendungen bereithalten die lokal angewendet werden können.

Zu guter letzt sollen Helfer Werkzeuge (Helper Tools) dafür sorgen mit dem eigentlichen Analyse-Prozess beginnen zu können um Profile, erfolgreich, zu kreieren.

---

Gliederung

1. eine GUI-Desktop Anwendung
2. eine Onlineschnittstelle
3. Profil-Aufbau
4. Helper-Tools

---

1. Die GUI-Anwendung, möglicher Flow

Kernfunktionen der GUI-App

• Navigiere zu einem Ordner und setze diesen als "Quellordner" für das Spiel (idealerweise das langsamere Laufwerk wo die Daten permanent verbleiben)
• Setze den Namen für das Profil und eine eventuelle Version (leer = keine Angabe)
• Klick auf "Analyze" und lasse die App die LastAccess, ModificationTime, Größe erfassen aus dem Quellordner
• Selektiere Dateien oder ganzen Ordner aus dem Quellordner, die kopiert werden sollen, für die Symlinks
• Erstelle / Navigiere zu einem Zielordner, in den die Auswahl später kopiert werden soll (dies kann aus Optionen auch ein fixer Oberordner sein, mit Spielname als Titel aus der Eingabe für den Unterordner)
• Wähle "split-that-game" was:
• Die Inhalte verschiebt und gegebenenfalls prüft, ob diese nicht schon in Zielordner existieren bzw. ob diese verändert worden sind (LastAccess, ModificationTime).
• Die Symlinks in Quellordner setzt zu Dateien und Ordnern - so fern nicht vorhanden
• Speichere die aktuelle Einstellung im aktiven Profil (bzw. das eigene lokale Profil) für das Spiel oder die Anwendung
• (hier wäre eine File-Based Lösung gut: /split-that-game/userProfiles/localId.stg)
• Meta-Informationen landen ebenfalls in der lokalen Datenbank
• Speichere die Dateninformation in der lokalen DB für spätere Vergleiche - dies könnt den JSON Output von PayLoadTimer.py verwenden und oder einer eigenen integrierten Funktion.

---

Weitere Features

• Eingabe der Profil Eckdaten, siehe 2.
• Erstellen/Verwalten einer MD5 Checksumme für die Spiel/Anwendungs Executable/EXE
• Aufgrund von Beschränkungen in Windows Symlink: Aktivieren / Deaktivieren von Symlinks aus Profilen on demand
• Anzeige der verfügbaren Symlinks/Softlinks die verlinkt werden können
• Windows > a limit of 63 reparse points on any given path. ( https://docs.microsoft.com/en-us/windows/win32/fileio/reparse-points )
• Downloaden von Profilen aus der Onlineschnittstelle über eine API
  Beispiel: /split-that-game/gameProfiles/authorName_profileId.stg
• Informationen über die Profile landen außerdem in der Datenbank und werden auf Wahl Update profiles aktualisiert.
• Auswahl einer Spielversion welche in den Profilen enthalten ist.
• Bewertung von Dateien für die Scores 0 >= 10, wobei:
  10 = High Latency (oft genutzt)
  0 = Low Latency (wenig oder nur einmal genutzt)
• Upload des eigenen Profils zur Onlineversion (nach Registrierung), gegebenfalls mit Freischaltung oder Bewertung
• Auswahl des Betriebssystems und der Version des Spieles und Benutzer-Kommentar zum Profil
• Auswahl von eigenen und Community-Profilen
• Übersicht über alle Profile zu einem Spiel
• Inkompatible Versionen bzw. Angabe mit Version x.x.x getestet
• Angabe von Spielordner, die gescannt werden auf bestehende Spiele. Beispielsweise Gog/Steam/Epic auf bekannte Titel mit Profilvorschlägen so fern vorhanden
• Anzeige des freien Speichers auf der Symlink SSD/M2 - und die neue Belegung durch neue Symlinks/Daten in einer Vorschau
• Schnelle Deinstallation/Unlinking von Spielen und Anwendungen einhergehend mit einer Visualisierung des von Anwendungen belegten Platzes auf Link-Laufwerk
• Wenn Steam/Client Spiele mit gesetzten Symlinks aktualisiert/updated und Zeitstempel abweichen - Daten von SSD auf HDD synchronisieren um die Stammdaten aktuell zu halten damit nur ein Update gefahren werden muss.
• Hinweis auf zu aktualisierende Inhalte bei Klick auf "Refresh game contents" was ein Update durchführt zwischen HDD und SSD
• Setzen von Prioritäten/Scores für Dateien/Inhalte für Performance vs. Disk Usage Tradeoffs in Profilen

---

2. Profil-Aufbau

Analysedaten von Dateien sollten in einer SQLite DB landen. Heruntergeladene Profile in Dateien im JSON Format.

Beispiel: /split-that-game/gameProfiles/authorName_profileId.stg

• Autor
  • Autor Name => name
  • Email => email (Optional)

• Profile => profile
  • Id des Profiles => id
  • Basiert auf/abgeleitet von => basedOn (Id)
  • Kommentar => comment
  • Zeitstempel => times
    • Erstellt => created
    • Aktualisiert => changed
    • Gesamt-Score (siehe Details)=> score
• Spieldetails => game
  • MD5 Checksum (Main EXE) => gMd5
  • Spielname => gName
  • Spielversion => gVersion
  • Betriebssystem => gOs
  • Quellordner => gBase

Details

• Ordner /video (Relativ zu "gBase")
• stg_wholeLink = true/false (ganzes Verzeichnis Symlinken)
• stg_fileList (Dateiliste wenn nicht => stg_wholeLink = true)
  • Dateiname
    • Größe in Bytes => size
    • Linking-Status => linkStatus aktiv/inaktiv
    • Performance-Score 0 >= 10
      10 = High Load auf HDD
      5 = Medium Load auf HDD
      0 = Low oder One time Load auf HDD
    • Lokales Profil
      • Änderungszeit => mTime (modificationTime)
      • Zugriffszeit => aTime (accessTime)

---

3. Die Onlineschnittstelle

• Download von aktuellen Profilen (ohne Registrierung) mittels API im JSON Format
• Eintragen/Upload von Profilen
• Registrierung mit Benutzername/Email - nur für das Eintragen von Profilen und auch aus der GUI-App heraus möglich
• Online-Suche in der Datenbank nach Spiel und Anwendungsprofilen
• Bewertung von Profilen (negative könnten herausfliegen aus der Ansicht und sind nur über extra Knopfdruck sichtbar, bleiben aber in der Datenbank erhalten)

---

4. Helper Tools

• PythonSkript PayLoadTimer.py: Unter Linux und oder Windows die Zugriffe tracken um mögliche Profildaten zu gewinnen, soll in die GUI Anwendung fließen.
• PythonSkript VisualizePayload.py: Visualisiert den Namen, die Häufigkeit der Zugriffe und Abständen von Zugriffen auf Dateien nach einer Sitzung mit Ausgabe von PayLoadTimer.py. - Auch ein Kandidate für die GUI Lösung, also alles in einem.
• PowerShell SwitchLastAccess.ps1: Aktivieren und deaktivieren der LastAccessUpdate Option in Windows über fsutil.

Alle Informationen und Outlines finden sich ebenfalls hier: https://stg.dwrox.net

Im weiteren, ich würde da gern mit anfangen das Projekt vorzustellen um ersten Input zu sammeln und auch die Fragen zu klären wie und wo das Projekt, nach Mehrheitsentscheidung, dann gehostet wird zum Beispiel Gitlab oder Github war angedacht, just Git.

Zielplattformen sind Windows und Linux. Mac Support wäre ebenfalls naheliegend.

Außerdem wäre die Frage nach Teams, von je einem der Punkte eins bis vier, wobei Punkt drei als Referenz dienen soll.

Das sind:

1. GUI-Desktop Anwendung
2. die Onlineschnittstelle
3. Profile (Json Format)
4. Behilfswerkzeuge bzw. Helper Tools

Die Programmiersprachen und Tools/Frameworks sollen frei wählbar sein, wobei auf die Lizenz zu achten wäre. Kein Qt (Cute) - ansonsten kann alles verwendet werden.

Das Projekt soll unter der "GNU General Public License v3.0" Lizenz laufen, so wie auch die einzelnen Komponenten.

An euch als potentielle Teilnehmer folgende Fragen:

1. Hättet Ihr Interesse an dem Projekt mit zu arbeiten?
2. Nutzt Ihr lieber Gitlab oder Github? Was dann die Arbeit an dem Projekt koordinieren soll.
3. Welche Programmiersprache würdet ihr einsetzen wollen und welche Frameworks/Libraries
4. Würdet Ihr gerne im Team arbeiten oder doch eher allein? Entsprechende Bereiche würden dann auf Github oder Gitlab erstellt werden.

Anleitung um "LastAccessUpdate" unter Windows einzuschalten, was Standardmäßig deaktiviert ist:

1) Windows …[kw]cmd[/kw] - Kommandozeile als Admin starten
2) Den Status prüfen: [kw]fsutil behavior query DisableLastAccess[/kw] gibt den Status [kw]1 = an[/kw] oder [kw]0 = aus[/kw] zurück
3a) Zeitstempel aktivieren: [kw]fsutil behavior set DisableLastAccess 0[/kw] und Windows neu starten
3b) Zeitstempel deaktivieren: [kw]fsutil behavior set DisableLastAccess 1[/kw] und Windows neu starten

Nachdem die Option aktiviert ist, was etwas die Performance drücken kann, können mittels "PayLoadTimer.py" die Zugriffe protokolliert werden.

Hier eine Kurzanleitung wie ein Spiel oder Anwendung protokolliert werden kann:

1. Unter Windows mittels fsutil die Option [kw]DisableLastAccess[/kw] auf [kw]0[/kw] (Null) stellen und ausschalten
2. Pfad zum Spiel in [kw]PayLoadTimer.py[/kw] eintragen.
3. Spiel starten und spielen
4. Spiel beenden
5. [kw]PayLoadTimer.py[/kw] mit [kw]Strg + C[/kw] beenden, es wird eine JSON mit den Zugriffen erstellt, welche zur weiteren Analyse wichtig ist. Es wird in einer .stg (JSON Datei) gespeichert, ihr könnt euch gerne alle Daten dazu dann im Detail ansehen.

 

[DandG]

Ich verstehe sehr viel Bahnhof.


Meiner Meinung nach macht so etwas wenig Sinn bei Games
Es gibt so viele unterschiedliche Dateien die man nicht klar zuordnen kann, woher soll das Tool nun erkennen welche Datei man da braucht?
Das laden von der HDD auf die SSD würde dann absolut kein Sinn ergeben, da das Spiel mit sehr hoher Wahrscheinlichkeint abschmieren würde.
Und wenn man es irgendwie hinbekommen würde, wäre die Performance im Keller, da die Daten ja just in moment "rüber geschaufelt" werden.

Klar, interessant wäre es, allerdings stelle ich es mit bei Games fasst unmöglich vor.
Hingegen bei Anwendungen wie Photoshop etc. könnte ich es mir vorstellen das es da klappt, da sie meistens nur bruchteile von Daten nachschieben/benötigen.

 

[theSplit]

Ich verstehe sehr viel Bahnhof.

Kein Problem, ich versuche deine Fragen mal zu beleuchten.

Meiner Meinung nach macht so etwas wenig Sinn bei Games
Es gibt so viele unterschiedliche Dateien die man nicht klar zuordnen kann, woher soll das Tool nun erkennen welche Datei man da braucht?

Das ist relativ einfach, man kann unter Windows wie auch Linux einstellen, dass man die Zeit des letzten Zugriffes auf eine Datei vermerken lassen kann.
Dafür wäre der Helper "PayLoadTimer.py" da - dieses wird mit aktiven Zeiten des Zugriffs vor dem eigentlichen Spiel gestartet. Wenn das Spiel dann Dateien lädt, wird dies vermerkt und man kann sehen wie oft auf eine Datei - und in welchem Zeitabstand - auf diese zugegriffen wird. Das ist dann das Indiz wie häufig etwas geladen wird.

Das laden von der HDD auf die SSD würde dann absolut kein Sinn ergeben, da das Spiel mit sehr hoher Wahrscheinlichkeint abschmieren würde.
Und wenn man es irgendwie hinbekommen würde, wäre die Performance im Keller, da die Daten ja just in moment "rüber geschaufelt" werden.

Es wird nicht "on the fly" kopiert - also nicht in dem Moment wenn die Datei gebraucht wird - sondern im Vorfeld. Heißt, bevor das Spiel gestartet wird, werden virtuellen Verküpfungen von, vorher kopierten, Daten von der HDD auf die SSD kopiert und dann verknüpft. Für das Spiel wäre es praktisch so, als wäre das Spiel auf der HDD, bekommt aber indirekt Zugriff auf die SSD-Daten und somit die Geschwindigkeit der SSD.

Hingegen bei Anwendungen wie Photoshop etc. könnte ich es mir vorstellen das es da klappt, da sie meistens nur bruchteile von Daten nachschieben/benötigen.

Kann man sicherlich alles testen!

 

[DukeMan999]

Also dieses Projekt ist sicher nicht für Otto normal Sterbliche gedacht

Also für leute mit Hochschulabschluss:

Du willst nen Game haben was mittels der *.py datei den Datei zugriff protokolliert, einmal mit Speed(DisableLastAccess) und einmal ohne?!

MfG

 

[theSplit]

Du willst nen Game haben was mittels der *.py datei den Datei zugriff protokolliert, einmal mit Speed(DisableLastAccess) und einmal ohne?!

Wenn "DisableLastAccess" ausgeschaltet ist, also gleich 0 ist - erstellt Windows bei Zugriffen auf Dateien die Zeit für den letzten Zugriff auf die Datei, das ist Standardmäßig deaktiviert (gleich 1), auch weil es Performance kostet.

Das heißt, um eine Probe für ein Spiel zu erstellen schaltet man das "DisableLastAcces" aus - startet neu und startet dann, man braucht allerdings Python3, den "PayLoadTimer.py" mit dem entsprechenden Pfad - dieser muß aber in das Skript eingetragen werden. Das könnte man sicherlich aber noch schöner bzw. einfacher lösen.

Zum Beispiel unter Linux:
[kw]SRC_FOLDER = '/home/jan/GOG Games/Master of Magic' # Target folder to watch[/kw]

Für Windows ist das entsprechend abzuändern:
[kw]SRC_FOLDER = Laufwerk:\Pfad zum Spiel\Spielordner' # Target folder to watch[/kw]

Wenn das korrekt angegeben ist werden alle Dateizugriffe protokolliert.
Den PayLoadTimer.py kann man dann mittels [kw]Strg + C[/kw], nach Beenden des Spiels, wieder schließen - der läuft in einer Schleife. Danach wird ein ".json" angelegt die die ermittelten Zugriffe wie auch Pfade der Dateien enthält.

Edit:
Beispielpfad für Windowsin PayLoadTimer.py im Startbeitrag ergänzt.

Beispiel:
[src=python]# PayLoadTimer.py

# Linux Target folder to watch
SRC_FOLDER = '/home/jan/GOG Games/Master of Magic'

# Windows Target folder to watch, overwrites previous SRC_FOLDER
SRC_FOLDER = 'D:\\Gog Games\\Master of Magic'

# --------------------------------------------------------------[/src]

 

[rexcolo]

Github kollaboriert mit der amerikanischen Einwanderungsbehörde ICE, daher lieber Gitlab. Gibt aber auch noch dutzende andere Codehosting-Plattformen, z.B. notabug.org.

Warum Python und nicht z.B. Golang? Man muss ja ne Python Runtime laufen haben, das schränkt den Nutzen für Windows-Noobs schon mal ein. #bikeshedding

Wer ist die Zielgruppe?

Für mich ist das Projekt zu komplex, ich möchte ungern mit Dateisystemspäßen hantieren. Vielleicht fängt man bei der Kollaboration mal etwas kleiner an. Sqstorage war ja eigentlich recht beliebt und die Zusammenarbeit dort funktioniert soweit ich das sehe ganz OK.

Also dieses Projekt ist sicher nicht für Otto normal Sterbliche gedacht
Also für leute mit Hochschulabschluss

Finde ich jetzt bisschen unpassend. Frisch Ausstudierte haben meistens keine Ahnung vom Programmieren, das lernt man dort nämlich nicht wirklich.

 

[theSplit]

Github kollaboriert mit der amerikanischen Einwanderungsbehörde ICE, daher lieber Gitlab. Gibt aber auch noch dutzende andere Codehosting-Plattformen, z.B. notabug.org.

Wenn man dort, nachweislich, in Teams arbeiten kann, könnte man sich das gerne anschauen - wobei ich eher zu Github oder Gitlab greifen würde.

Warum Python und nicht z.B. Golang? Man muss ja ne Python Runtime laufen haben, das schränkt den Nutzen für Windows-Noobs schon mal ein. #bikeshedding

Python ist sicher nicht in Stein gemeiselt. So fern ein Repository steht, können wir gerne anfangen kompilierte Exe-Dateien - aus offenen Quellen, anzubieten was dann unabhängig davon läuft.

Wer ist die Zielgruppe?

Gamer und Anwender gleichermaßen.

Für mich ist das Projekt zu komplex, ich möchte ungern mit Dateisystemspäßen hantieren. Vielleicht fängt man bei der Kollaboration mal etwas kleiner an.

Die Idee wäre, das man sich in Teams für jeden Bereich, nach Möglichkeit, versucht aufzuteilen und zu organisieren - wobei das eine nicht das andere ausschließt. Heißt einige Arbeiten primär an einer Onlineschnittstelle, wieder andere an einer Desktop Anwendung. Und hinterher wird das zusammengebracht was zusammen gehört.

 

[rexcolo]

Ich glaube nicht, dass viele Spiele mit sowas klar kommen. Mit welchen Spielen/Anwendungen hast du es denn schon getestet?

Hast du noch eine andere Projektidee?

EDIT: Eventuell eine Plattform für Projektideen? Also auch sowas wie Challenges, mit denen man programmieren lernen kann?

Beispiele:
https://github.com/zverok/lmsa
https://github.com/fnplus/community-project-ideas
https://www.linuxtrainingacademy.com/projects/
http://www.ideamachine.io/
https://www.reddit.com/r/dailyprogrammer/

 

[theSplit]

Warum sollten Spiele oder Anwendungen damit nicht klarkommen?
Die Spiele oder Anwendungen sehen doch nur den Ordner und greifen darauf zu und das interne Auflösen macht das OS im Hintergrund.

Wenn du weitere Ideen hast, würde ich dich aber bitten hier zu schreiben: Diskussion-Programmierwettbewerb-Talk - da dieses Thema hier wirklich nur für dieses Projekt gedacht ist.

 

[BurnerR]

Hab dir ja schon geschrieben, dass ich finde das es ganz cool klingt.

Vielleicht den Ablauf noch ganz oben einfügen?

1. split-that-game analyse starten
2. Spiel starten und spielen
3. Spiel beenden
4. split-that-game splitter schaufelt jetzt 30 der 50 GB von meiner 256 GB SSD auf die 5 TB HD.
5. Ich habe jetzt 30 GB mehr Platz auf der SSD ohne spürbaren (so die Idee ) Performanceverslust


Machbarkeit wurde hier ja auch angesprochen, dass sollte man auf jeden Fall noch ausführlicher prüfen.
Performance von Dir Joints? Geht das immer oder geht das schief bei DLLs o.ä.? ..

 

[theSplit]

Ich hab mal das "Wie protokollieren?" in der Einleitung ergänzt - also den Umgang mit dem "PayLoadTimer.py"-Skript .

Testen kann man das ja mit jeder Anwendung oder Spiel, einfach dazu: [kw]mklink[/kw] -> mklink (Überblick/Anleitung) unter Windows verwenden oder [kw]ln -s[/kw] -> Überblick - unter Linux.

 

[exomo]

Coller als ein Python Script fände ich wenn man die Analyse auch direkt im Tool machen könnte.

Ich würde auch vorschlagen wir machen erst mal ein "proof of concept" zu machen, also mal zumindest bei ein paar Spielen Dateien auf eine andere Platte schieben und schauen ob das Spiel noch funktioniert. Wenn wir genügend positive Test haben könnten wir auch mal testen wie sich das auf die Performance auswirkt.

Und so kompliziert finde ich das ganze jetzt nicht, dass man es nicht mal umsetzen könnte. Natürlich braucht eine komplette Umsetzung einiges an Arbeit, aber wenn man die Teilsysteme einzeln angeht kann ich mir schon vorstellen dass da was bei rauskommt.

 

[rexcolo]

denke ein MVP zu programmieren wäre erst mal sinnvoll; also ein Script was das mklink-Zeuch übernimmt.

ich wäre dabei, allerdings würde ich am Liebsten das API Design übernehmen. Wenn serverseitig programmiert werden soll kann ich eigentlich nur Java, Python und Go anbieten. PHP verwende ich aus Prinzip für neue Projekte nicht.

EDIT: hm also ich hab mir noch mal allles durchgelesen und irgendwie sehe ich den Sinn bzw die Machbarkeit immer noch nicht.
entweder lebt bei mir ein Game auf der SSD oder auf ner HDD (wobei ich keine HDDs mehr habe).
das Ding ist also ausschließlich für arme Leute interessant, die keine Geld für große SSDs haben. Zielgruppe "Gamer" ist also nicht genau genug.

EDIT2: hm, https://www.traynier.com/software/steammover arbeitet auch mit Junctions.

EDIT3: hier in der "Collection of Steam Tools" unter "Software Pt. 3" findet man auch folgende Tools die ähnliche Dinge tun:

• Game Pipe – Automates the movement of Steam games from drive to drive or pc to pc.
• Relief Valve – Prevents dangerous Steam buildups by letting you move games between library locations.
• Steam Apps Manager – Windows software to move Steam apps between disks.
• Steam Library Explorer – Explorer for your Steam game libraries.
• Steam Library Manager – SLM is a tool created to help you with managing Steam libraries. SLM lets you easily copy, move or backup your games between Steam and SLM (backup) libraries.
• Steam Tunnel – Steam Tunnel is a real steam game mover, symlinks are not used.
• Steam Mover – Move your games to another partition (Windows only). [den hatten wir ja schon]
• SteamTool Library Manager – This app will move your games to another partition. Windows only.
• Virtual Game Shelf – Virtual Game Shelf is a desktop Java application to organize your game library in a single convenient location.

 

[theSplit]

@exomo: Ich hab deinen Wunsch mal ergänzt und jenen unter dem Punkt "Helper Tools" entsprechend, in den Beschreibungen, notiert.
Denke auch, die Analyse für Profile und die Darstellung der Nutzungszeiten sollten, komplett, in der Desktop-Anwendung Platz finden.

@rexcolo: Ein "MVP" wäre in der Tat gut - das könnte/würde ich noch in einem kleinen Python-Skript unterbringen - zumindest das man schon einmal testen kann wie sich die Symlinks oder Junctions auswirken. Und um leichter zu testen können.

Python würde ich halt deshalb nehmen, da das Prototyping schnell von der Hand geht. Das kann man dann sicherlich alles noch umbacken in eine kompilierte Sprache - wenn es denn soweit ist.

Was man aber auch ohne große Umwege testen kann:
1) ein Spiel auf eine HDD installieren
2) eine Handvoll "Verzeichnisse" auf eine SSD in einen, vorher festgelegten. Pfad zu kopieren
3) in den Spieleordner Symlinks setzen auf diese Verzeichnisse aus dem Spieleordner heraus.
4) Spiel starten und anspielen

Wenn man will, kann man das noch weiter eingrenzen auf bestimme Dateien, aber so sieht man schon ob es geht oder nicht geht.

 

[theSplit]

Helper Tools Source Code

Hier mal die Source Codes für die aktuellen Python Helper - ich habe noch ein paar kleinere Fehler behoben die mir beim Testen aufgefallen sind.
[kw]VisualizePayLoad.py[/kw] braucht zusätzlich Matplotlib für die Generierung der Charts.


[src=python]# PayLoadTimer.py

import signal
from json import dump, dumps
from time import sleep, time
from glob import glob
from os import stat, path, sep

# Linux Target folder to watch
SRC_FOLDER = '/home/jan/GOG Games/Master of Magic'

# Windows Target folder to watch, overwrites previous SRC_FOLDER
# Use # in front to comment out
#SRC_FOLDER = 'C:\\Games\\Master of Magic'

# --------------------------------------------------------------
STRIP_SRC = True # Remove src folder path from output, True/False
SRC_CHECK_INTERVAL = 20 # Time to check for file changes in seconds
# --------------------------------------------------------------

signal.signal(signal.SIGINT, signal.default_int_handler)

fileData = {}


def getFolders(rootFolder):
return glob(f'{rootFolder}{sep}**', recursive=True)


def getFileAtime(targetFile):
return stat(targetFile).st_atime


def getFileSize(targetFile):
return path.getsize(targetFile)


def noteChanges(fileDataKeys, fileData, outputFileName):
try:
for fileEntry in fileDataKeys:
accessTime = getFileAtime(fileEntry)
if fileData['files'][fileEntry]['last'] != accessTime:
fileData['files'][fileEntry]['time'].append(accessTime)
fileData['files'][fileEntry]['cnt'] += 1
fileData['files'][fileEntry]['last'] = accessTime
print(f'Updated entry: {fileEntry} - {accessTime}')

sleep(SRC_CHECK_INTERVAL)
noteChanges(fileDataKeys, fileData, outputFileName)
except KeyboardInterrupt as e:
print(f'\nYes my grace.. saving data to: {outputFileName}')
with open(outputFileName, "w") as outputFile:
fileData['src_time_end'] = int(time())

if STRIP_SRC:
srcFolder = fileData['src_folder']
del fileData['src_folder']
jsonData = dumps(fileData)
jsonData = jsonData.replace(srcFolder, '')
removalString = srcFolder.replace('\\', '\\\\')
jsonData = jsonData.replace(removalString, '')
outputFile.write(jsonData)
else:
dump(fileData, outputFile)

exit(0)


def fillFileData(folders, srcFolder):
fileData = {}
fileData['files'] = {}
fileData['src_folder'] = srcFolder
fileData['basedir'] = baseFolder[-1]
fileData['src_time'] = int(time())
fileData['src_time_start'] = int(time())
fileData['src_time_end'] = 0

for folder in folders:
folderFiles = glob(f"{folder}**")

for fileEntry in folderFiles:
accessTime = getFileAtime(fileEntry)
fileSize = getFileSize(fileEntry)
fileData['files'][fileEntry] = {
'time': [], 'cnt': 0,
'init': accessTime, 'last': accessTime,
'size': fileSize
}
return fileData


# --------------------------------------------------------------

baseFolder = path.split(SRC_FOLDER)

outputFileName = 'Log_' + baseFolder[-1] + '_' + str(int(time())) + '.json'

fileData = fillFileData(getFolders(SRC_FOLDER), SRC_FOLDER)
fileDataKeys = fileData['files'].keys()
noteChanges(fileDataKeys, fileData, outputFileName)

[/src]

und

[src=python]# VisualizePayLoad.py

from json import load
from glob import glob
import matplotlib.pyplot as plt
from pprint import pprint

SRC_FILES = glob('Log_*.json')

for srcFile in SRC_FILES:
with open(srcFile, 'r') as inputFile:
jsonInput = load(inputFile)
keys = jsonInput['files'].keys()
fileEntries = [key.strip('\\').strip('/') for key in keys]
pprint(fileEntries)
plt.rcdefaults()
plt.rcParams['figure.figsize'] = [70, len(keys) * 0.4]
fig, ax = plt.subplots()
cnt = []
for key in keys:
cnt.append(jsonInput['files'][key]['cnt'])

ax.barh(fileEntries, cnt, align='center')
ax.set_yticks(fileEntries)
ax.set_yticklabels(fileEntries)
ax.invert_yaxis() # labels read top-to-bottom
ax.set_xlabel('File calls')
ax.set_title(f"File usage")

plt.savefig(f"{jsonInput['basedir']}.png")

[/src]

--- [2020-04-18 14:38 CEST] Automatisch zusammengeführter Beitrag ---

Und hier zwei Beispielausgaben der JSON mit VisualizePayLoad.py:

Dawn of Man



Frostpunk

 

[DandG]

@theSplit: Hat ein bischen gedauert

Das ist relativ einfach, man kann unter Windows wie auch Linux einstellen, dass man die Zeit des letzten Zugriffes auf eine Datei vermerken lassen kann.

Achso, also muss man das Game mind. 1x durchgespielt haben?
Dann macht das wenig Sinn, viele Spiele spielt man nur 1x druch, klar, da gibt es auch Ausnahmen.
Es sei denn man legt online eine Datenbank an, auf diese dann jeder zugreifen kann wenn man das gleiche Spiel erst anfängt.

Dafür wäre der Helper "PayLoadTimer.py" da - dieses wird mit aktiven Zeiten des Zugriffs vor dem eigentlichen Spiel gestartet. Wenn das Spiel dann Dateien lädt, wird dies vermerkt und man kann sehen wie oft auf eine Datei - und in welchem Zeitabstand - auf diese zugegriffen wird. Das ist dann das Indiz wie häufig etwas geladen wird.

Wie wirkt es sich dann auf die Performance aus?
Nicht jeder hat ein "Gaming-PC" mit genug Leistungsreserven.

Es wird nicht "on the fly" kopiert - also nicht in dem Moment wenn die Datei gebraucht wird - sondern im Vorfeld. Heißt, bevor das Spiel gestartet wird, werden virtuellen Verküpfungen von, vorher kopierten, Daten von der HDD auf die SSD kopiert und dann verknüpft. Für das Spiel wäre es praktisch so, als wäre das Spiel auf der HDD, bekommt aber indirekt Zugriff auf die SSD-Daten und somit die Geschwindigkeit der SSD.

Habe eben mal nachgeschaut, teilweise sind einzelne Dateien/Abschnitte 12GB groß, ich bin da echt gespannt wie es sich dann verhält, kann ja sein das man die Datei bei Spielstart braucht.
Nun lad mal eine 12GB datei von ner HDD, geht, aber die damit verbundene Wartezeit wäre dann der "killer".
Der "normale Gamer" möchte nicht warten bis alles erst einmal geladen ist, die Zeiten bei dem man in der Ladezeit nen Kaffee trinken konnte ist schon lange rum

Nicht falsch vertstehen, soweit wie ich es verstanden habe ist es ein interessantes Thema, doch stelle ich es mir nicht so einfach vor, wenn man es bei Spiele anwenden sollte.


PS: wäre genial wenn man da ne einfach zu verstehende gui draufklatschen könnte und alles als exe verkleiden kann. (für windows normal user)

 

[theSplit]

Achso, also muss man das Game mind. 1x durchgespielt haben?

Ich denke nicht. Man kann ja schon beim Start und in/mit 1-2 Stunden Gameplay sehen was wie oft geladen wird - so die Idee.

Dann macht das wenig Sinn, viele Spiele spielt man nur 1x druch, klar, da gibt es auch Ausnahmen.
Es sei denn man legt online eine Datenbank an, auf diese dann jeder zugreifen kann wenn man das gleiche Spiel erst anfängt.

Genau das ist der Plan. Man kann sich selbst "Profile" erstellen für Spiele, man kann aber auch - so ist die Planung, Online auf eine Datenbank mit Profilen anderer zugreifen. Im Idealfalls gibt es dann für das Spiel bereits ein Profil das man dann einfach anwenden lassen kann.

Wie wirkt es sich dann auf die Performance aus?
Nicht jeder hat ein "Gaming-PC" mit genug Leistungsreserven.

Die CPU arbeitet minimal mehr. Aber einen Performance-Einbruch sollte es wegen der Aufzeichnung nicht geben.

Habe eben mal nachgeschaut, teilweise sind einzelne Dateien/Abschnitte 12GB groß, ich bin da echt gespannt wie es sich dann verhält, kann ja sein das man die Datei bei Spielstart braucht.
Nun lad mal eine 12GB datei von ner HDD, geht, aber die damit verbundene Wartezeit wäre dann der "killer".

Das variiert vermutlich stark von Spiel zu Spiel bzw. Anwendung zu Anwendung. Wenn nur einmal auf die großen Dateien zugegriffen wird könnte man diese Auslagern, aber alles im Spiel wird wohl im Rahmen von < 8 GB RAM sein. Das kann heißen, es wird nur auf einen Teil der Datei(en) zugegriffen bzw. um Texturen vorzuladen oder ähnliches, aber nicht alle 15 GB auf einmal gelesen werden, wo dann vielleicht nicht der Speed der SSD zum Tragen kommt und eine Übertragung mittels HDD ausreicht.

Nicht falsch vertstehen, soweit wie ich es verstanden habe ist es ein interessantes Thema, doch stelle ich es mir nicht so einfach vor, wenn man es bei Spiele anwenden sollte.

Alles gut, Feedback ist willkommen und ich finde das sind valide Punkte.

PS: wäre genial wenn man da ne einfach zu verstehende gui draufklatschen könnte und alles als exe verkleiden kann. (für windows normal user)

Eine GUI wäre auch der Plan, langfristig. Und dann vermutlich auch weg von Python als Skript/Programmiersprache.

 

[rexcolo]

Lad das bitte in ein Repository.

Kannst ja erst mal einen Ordner "helper-scripts" anlegen und da alles reinpacken was random scripts sind.

Unter Linux kann man mit inotify Ordner überwachen. Ich fände es cool wenn man einfach [kw]PayLoadTimer.py pfad/zum/spiele/binary[/kw] eingeben könnte und dann direkt profiliert wird.

Man könnte ja auch den "Grad" der Auslagerung angeben und z.B. die 10% häufigst benutzten Dateien auslagern oder die 20% etc.

[src=python]$ pylint-3 payloadtimer.py
************* Module payloadtimer
payloadtimer.py:8:2: W1401: Anomalous backslash in string: '\G'. String constant might be missing an r prefix. (anomalous-backslash-in-string)
payloadtimer.py:8:8: W1401: Anomalous backslash in string: '\M'. String constant might be missing an r prefix. (anomalous-backslash-in-string)
payloadtimer.py:2:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:5:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:9:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:19:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:22:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:24:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:27:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:30:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:33:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:43:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:50:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:59:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:61:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:62:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:71:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:74:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:78:0: C0301: Line too long (123/100) (line-too-long)
payloadtimer.py:80:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:84:0: C0303: Trailing whitespace (trailing-whitespace)
payloadtimer.py:1:0: C0114: Missing module docstring (missing-module-docstring)
payloadtimer.py:14:0: C0413: Import "from os import stat, path, fstat" should be placed at the top of the module (wrong-import-position)
payloadtimer.py:15:0: C0413: Import "from glob import glob" should be placed at the top of the module (wrong-import-position)
payloadtimer.py:16:0: C0413: Import "from time import sleep, time" should be placed at the top of the module (wrong-import-position)
payloadtimer.py:17:0: C0413: Import "from json import dump, dumps" should be placed at the top of the module (wrong-import-position)
payloadtimer.py:18:0: C0413: Import "import os" should be placed at the top of the module (wrong-import-position)
payloadtimer.py:20:0: C0413: Import "import signal" should be placed at the top of the module (wrong-import-position)
payloadtimer.py:23:0: C0103: Constant name "fileData" doesn't conform to UPPER_CASE naming style (invalid-name)
payloadtimer.py:25:0: C0103: Function name "getFolders" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:25:0: C0103: Argument name "rootFolder" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:25:0: C0116: Missing function or method docstring (missing-function-docstring)
payloadtimer.py:28:0: C0103: Function name "getFileAtime" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:28:0: C0103: Argument name "targetFile" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:28:0: C0116: Missing function or method docstring (missing-function-docstring)
payloadtimer.py:31:0: C0103: Function name "getFileSize" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:31:0: C0103: Argument name "targetFile" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:31:0: C0116: Missing function or method docstring (missing-function-docstring)
payloadtimer.py:34:0: C0103: Function name "noteChanges" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:34:0: C0103: Argument name "fileDataKeys" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:34:0: C0103: Argument name "fileData" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:34:0: C0103: Argument name "outputFileName" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:34:0: C0116: Missing function or method docstring (missing-function-docstring)
payloadtimer.py:34:16: W0621: Redefining name 'fileDataKeys' from outer scope (line 86) (redefined-outer-name)
payloadtimer.py:34:30: W0621: Redefining name 'fileData' from outer scope (line 23) (redefined-outer-name)
payloadtimer.py:34:40: W0621: Redefining name 'outputFileName' from outer scope (line 83) (redefined-outer-name)
payloadtimer.py:36:12: C0103: Variable name "fileEntry" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:37:12: C0103: Variable name "accessTime" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:46:4: C0103: Variable name "e" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:48:42: C0103: Variable name "outputFile" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:52:16: C0103: Variable name "jsonData" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:53:16: C0103: Variable name "jsonData" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:54:16: C0103: Variable name "removalString" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:55:16: C0103: Variable name "jsonData" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:60:8: R1722: Consider using sys.exit() (consider-using-sys-exit)
payloadtimer.py:46:4: W0612: Unused variable 'e' (unused-variable)
payloadtimer.py:63:0: C0103: Function name "fillFileData" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:63:0: C0103: Argument name "srcFolder" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:63:0: C0116: Missing function or method docstring (missing-function-docstring)
payloadtimer.py:64:4: W0621: Redefining name 'fileData' from outer scope (line 23) (redefined-outer-name)
payloadtimer.py:64:4: C0103: Variable name "fileData" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:73:8: C0103: Variable name "folderFiles" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:75:12: C0103: Variable name "fileEntry" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:76:12: C0103: Variable name "accessTime" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:77:12: C0103: Variable name "fileSize" doesn't conform to snake_case naming style (invalid-name)
payloadtimer.py:82:0: C0103: Constant name "baseFolder" doesn't conform to UPPER_CASE naming style (invalid-name)
payloadtimer.py:83:0: C0103: Constant name "outputFileName" doesn't conform to UPPER_CASE naming style (invalid-name)
payloadtimer.py:85:0: C0103: Constant name "fileData" doesn't conform to UPPER_CASE naming style (invalid-name)
payloadtimer.py:86:0: C0103: Constant name "fileDataKeys" doesn't conform to UPPER_CASE naming style (invalid-name)
payloadtimer.py:14:0: W0611: Unused fstat imported from os (unused-import)

------------------------------------
Your code has been rated at -1.48/10[/src]

EDIT: habe das Tool über Guild Wars 2 laufen lassen.

[src=json]
{"files": {"/GW2-64.exe": {"time": [], "cnt": 0, "init": 1587199754.8888264, "last": 1587199754.8888264, "size": 34004648}, "/ArenaNet.log": {"time": [], "cnt": 0, "init": 1583572802.177219, "last": 1583572802.177219, "size": 41350}, "/Crash.dmp": {"time": [], "cnt": 0, "init": 1583572822.524775, "last": 1583572822.524775, "size": 22819}, "/GW2-64.tmp": {"time": [], "cnt": 0, "init": 1587071648.8055863, "last": 1587071648.8055863, "size": 0}, "/Gw2.dat": {"time": [1587232384.3014972], "cnt": 1, "init": 1587199758.2257605, "last": 1587232384.3014972, "size": 50192927816}, "/Gw2.tmp": {"time": [], "cnt": 0, "init": 1583572991.880257, "last": 1583572991.880257, "size": 0}, "/bin64": {"time": [], "cnt": 0, "init": 1587199758.6187527, "last": 1587199758.6187527, "size": 212}, "/THIRDPARTYSOFTWAREREADME.txt": {"time": [1587232384.3054972], "cnt": 1, "init": 1587199758.2297604, "last": 1587232384.3054972, "size": 567400}, "/GW2-64.dxvk-cache": {"time": [1587232410.4869196], "cnt": 1, "init": 1587199773.5094585, "last": 1587232410.4869196, "size": 4825392}, "/bin64/CoherentUI_Host.exe": {"time": [1587232384.306497], "cnt": 1, "init": 1587199758.2317603, "last": 1587232384.306497, "size": 36143096}, "/bin64/CoherentUI64.dll": {"time": [1587232384.3344965], "cnt": 1, "init": 1587199758.3217585, "last": 1587232384.3344965, "size": 1106424}, "/bin64/icudt.dll": {"time": [1587232385.309475, 1587232414.7738252], "cnt": 2, "init": 1587199777.7823744, "last": 1587232414.7738252, "size": 9962488}, "/bin64/libEGL.dll": {"time": [1587232384.449494, 1587232414.3948336], "cnt": 2, "init": 1587199777.4243813, "last": 1587232414.3948336, "size": 110072}, "/bin64/libGLESv2.dll": {"time": [1587232384.451494, 1587232414.3988333], "cnt": 2, "init": 1587199777.4273813, "last": 1587232414.3988333, "size": 890360}, "/bin64/d3dcompiler_43.dll": {"time": [1587232384.4634936, 1587232414.411833], "cnt": 2, "init": 1587199777.4393811, "last": 1587232414.411833, "size": 2106216}, "/bin64/ffmpegsumo.dll": {"time": [1587232384.4884932, 1587232386.036459, 1587232418.8257358], "cnt": 3, "init": 1587199781.845294, "last": 1587232418.8257358, "size": 867832}, "/bin64/locales": {"time": [], "cnt": 0, "init": 1587199759.566734, "last": 1587199759.566734, "size": 0}}, "src_folder": "", "basedir": "Guild Wars 2", "src_time": 1587232375, "src_time_start": 1587232375, "src_time_end": 1587232580}[/src]

[src=bash]$ tree
.
├── ArenaNet.log
├── bin64
│** ├── CoherentUI64.dll
│** ├── CoherentUI_Host.exe
│** ├── d3dcompiler_43.dll
│** ├── ffmpegsumo.dll
│** ├── icudt.dll
│** ├── libEGL.dll
│** ├── libGLESv2.dll
│** └── locales
├── Crash.dmp
├── GW2-64.dxvk-cache
├── GW2-64.exe
├── GW2-64.tmp
├── Gw2.dat
├── Gw2.tmp
└── THIRDPARTYSOFTWAREREADME.txt[/src]

 

[theSplit]

@rexcolo: Bezüglich eines Repositorys, das wird kommen, ganz sicher. Ich spreche das mal mit den anderen, im NGB-Team, ab.

Edit: Hast du auch mal versucht das zu Symlinken, weil die Frage wegen der DLL-Dateien ja aufgekommen ist oder die dann noch funktioniern und gefunden werden?

 

[rexcolo]

Habe alles mit Symlinks verschoben und WINE meckert nicht, dafür SELinux.

Na ja, wenn alle Dateien genutzt werden – die DAT-Datei ist sehr groß – ergibt das Verschieben gar keinen Sinn. Einzelne Chunks kann man ja leider nicht auslagern.

Wird bei anderen Games, die Streaming und riesige Binary-Dateien nutzen, nicht viel anders aussehen.