Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 25 von 29

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

  1. #1
    since 1998

    Moderator

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    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/win...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(n) 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 …cmd - Kommandozeile als Admin starten
    2) Den Status prüfen: fsutil behavior query DisableLastAccess gibt den Status 1 = an oder 0 = aus zurück
    3a) Zeitstempel aktivieren: fsutil behavior set DisableLastAccess 0 und Windows neu starten
    3b) Zeitstempel deaktivieren: fsutil behavior set DisableLastAccess 1 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 DisableLastAccess auf 0 (Null) stellen und ausschalten
    2. Pfad zum Spiel in PayLoadTimer.py eintragen.
    3. Spiel starten und spielen
    4. Spiel beenden
    5. PayLoadTimer.py mit Strg + C 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.
    Für diesen Beitrag bedanken sich Roin, cavin
    Geändert von theSplit (19.04.20 um 20:49 Uhr) Grund: PayLoadTimer.py uhnd VisualizePayLoad.py aktualisiert

  2. #2
    Such da fuq Avatar von DandG
    Registriert seit
    Jun 2016
    Ort
    In mein Haus.
    Beiträge
    1.595

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

    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.
    Für diesen Beitrag bedankt sich Kenobi van Gin
    Geändert von DandG (16.04.20 um 01:14 Uhr)

  3. #3
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Zitat Zitat von DandG Beitrag anzeigen
    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!
    Für diesen Beitrag bedankt sich DandG

  4. #4
    Duke Nukem Master Avatar von DukeMan999
    Registriert seit
    Jul 2013
    Beiträge
    234

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

    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

  5. #5
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Zitat Zitat von DukeMan999 Beitrag anzeigen
    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:
    SRC_FOLDER = '/home/jan/GOG Games/Master of Magic' # Target folder to watch

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

    Wenn das korrekt angegeben ist werden alle Dateizugriffe protokolliert.
    Den PayLoadTimer.py kann man dann mittels Strg + C, 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:
    Code (Python):
    1. # PayLoadTimer.py
    2.  
    3. # Linux Target folder to watch
    4. SRC_FOLDER = '/home/jan/GOG Games/Master of Magic'
    5.  
    6. # Windows Target folder to watch, overwrites previous SRC_FOLDER
    7. SRC_FOLDER = 'D:\\Gog Games\\Master of Magic'
    8.  
    9. # --------------------------------------------------------------
    Geändert von theSplit (19.04.20 um 10:51 Uhr)

  6. #6

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

    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.

    Zitat Zitat von DukeMan999 Beitrag anzeigen
    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.

  7. #7
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Zitat Zitat von rexcolo Beitrag anzeigen
    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.

  8. #8

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

    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/

  9. #9
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    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.
    Geändert von theSplit (16.04.20 um 17:18 Uhr)

  10. #10
    Bot #0384479 Avatar von BurnerR
    Registriert seit
    Jul 2013
    Beiträge
    4.689
    ngb:news Artikel
    3

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

    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.ä.? ..
    Für diesen Beitrag bedankt sich rexcolo

  11. #11
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    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: mklink -> mklink (Überblick/Anleitung) unter Windows verwenden oder ln -s -> Überblick - unter Linux.
    Geändert von theSplit (16.04.20 um 17:51 Uhr)

  12. #12
    Mitglied
    Registriert seit
    Aug 2015
    Beiträge
    122

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

    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.
    Für diesen Beitrag bedankt sich BurnerR

  13. #13

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

    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.
    Geändert von rexcolo (16.04.20 um 19:46 Uhr)

  14. #14
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    @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.
    Für diesen Beitrag bedankt sich rexcolo

  15. #15
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

    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.
    VisualizePayLoad.py braucht zusätzlich Matplotlib für die Generierung der Charts.


    Code (Python):
    1. # PayLoadTimer.py
    2.  
    3. import signal
    4. from json import dump, dumps
    5. from time import sleep, time
    6. from glob import glob
    7. from os import stat, path, sep
    8.  
    9. # Linux Target folder to watch
    10. SRC_FOLDER = '/home/jan/GOG Games/Master of Magic'
    11.  
    12. # Windows Target folder to watch, overwrites previous SRC_FOLDER
    13. # Use # in front to comment out
    14. #SRC_FOLDER = 'C:\\Games\\Master of Magic'
    15.  
    16. # --------------------------------------------------------------
    17. STRIP_SRC = True  # Remove src folder path from output, True/False
    18. SRC_CHECK_INTERVAL = 20  # Time to check for file changes in seconds
    19. # --------------------------------------------------------------
    20.  
    21. signal.signal(signal.SIGINT, signal.default_int_handler)
    22.  
    23. fileData = {}
    24.  
    25.  
    26. def getFolders(rootFolder):
    27.     return glob(f'{rootFolder}{sep}**', recursive=True)
    28.  
    29.  
    30. def getFileAtime(targetFile):
    31.     return stat(targetFile).st_atime
    32.  
    33.  
    34. def getFileSize(targetFile):
    35.     return path.getsize(targetFile)
    36.  
    37.  
    38. def noteChanges(fileDataKeys, fileData, outputFileName):
    39.     try:
    40.         for fileEntry in fileDataKeys:
    41.             accessTime = getFileAtime(fileEntry)
    42.             if fileData['files'][fileEntry]['last'] != accessTime:
    43.                 fileData['files'][fileEntry]['time'].append(accessTime)
    44.                 fileData['files'][fileEntry]['cnt'] += 1
    45.                 fileData['files'][fileEntry]['last'] = accessTime
    46.                 print(f'Updated entry: {fileEntry} - {accessTime}')
    47.  
    48.         sleep(SRC_CHECK_INTERVAL)
    49.         noteChanges(fileDataKeys, fileData, outputFileName)
    50.     except KeyboardInterrupt as e:
    51.         print(f'\nYes my grace.. saving data to: {outputFileName}')
    52.         with open(outputFileName, "w") as outputFile:
    53.             fileData['src_time_end'] = int(time())
    54.  
    55.             if STRIP_SRC:
    56.                 srcFolder = fileData['src_folder']
    57.                 del fileData['src_folder']
    58.                 jsonData = dumps(fileData)
    59.                 jsonData = jsonData.replace(srcFolder, '')
    60.                 removalString = srcFolder.replace('\\', '\\\\')
    61.                 jsonData = jsonData.replace(removalString, '')
    62.                 outputFile.write(jsonData)
    63.             else:
    64.                 dump(fileData, outputFile)
    65.  
    66.         exit(0)
    67.  
    68.  
    69. def fillFileData(folders, srcFolder):
    70.     fileData = {}
    71.     fileData['files'] = {}
    72.     fileData['src_folder'] = srcFolder
    73.     fileData['basedir'] = baseFolder[-1]
    74.     fileData['src_time'] = int(time())
    75.     fileData['src_time_start'] = int(time())
    76.     fileData['src_time_end'] = 0
    77.  
    78.     for folder in folders:
    79.         folderFiles = glob(f"{folder}**")
    80.  
    81.         for fileEntry in folderFiles:
    82.             accessTime = getFileAtime(fileEntry)
    83.             fileSize = getFileSize(fileEntry)
    84.             fileData['files'][fileEntry] = {
    85.                 'time': [], 'cnt': 0,
    86.                 'init': accessTime, 'last': accessTime,
    87.                 'size': fileSize
    88.             }
    89.     return fileData
    90.  
    91.  
    92. # --------------------------------------------------------------
    93.  
    94. baseFolder = path.split(SRC_FOLDER)
    95.  
    96. outputFileName = 'Log_' + baseFolder[-1] + '_' + str(int(time())) + '.json'
    97.  
    98. fileData = fillFileData(getFolders(SRC_FOLDER), SRC_FOLDER)
    99. fileDataKeys = fileData['files'].keys()
    100. noteChanges(fileDataKeys, fileData, outputFileName)
    101.  
    102.  
    und

    Code (Python):
    1. # VisualizePayLoad.py
    2.  
    3. from json import load
    4. from glob import glob
    5. import matplotlib.pyplot as plt
    6. from pprint import pprint
    7.  
    8. SRC_FILES = glob('Log_*.json')
    9.  
    10. for srcFile in SRC_FILES:
    11.     with open(srcFile, 'r') as inputFile:
    12.         jsonInput = load(inputFile)
    13.         keys = jsonInput['files'].keys()
    14.         fileEntries = [key.strip('\\').strip('/') for key in keys]
    15.         pprint(fileEntries)
    16.         plt.rcdefaults()
    17.         plt.rcParams['figure.figsize'] = [70, len(keys) * 0.4]
    18.         fig, ax = plt.subplots()
    19.         cnt = []
    20.         for key in keys:
    21.             cnt.append(jsonInput['files'][key]['cnt'])
    22.  
    23.         ax.barh(fileEntries, cnt, align='center')
    24.         ax.set_yticks(fileEntries)
    25.         ax.set_yticklabels(fileEntries)
    26.         ax.invert_yaxis()  # labels read top-to-bottom
    27.         ax.set_xlabel('File calls')
    28.         ax.set_title(f"File usage")
    29.  
    30.         plt.savefig(f"{jsonInput['basedir']}.png")
    31.  
    32.  
    --- [2020-04-18 14:38 CEST] Automatisch zusammengeführter Beitrag ---

    Und hier zwei Beispielausgaben der JSON mit VisualizePayLoad.py:

    Dawn of Man



    Frostpunk
    Geändert von theSplit (19.04.20 um 16:52 Uhr)

  16. #16
    Such da fuq Avatar von DandG
    Registriert seit
    Jun 2016
    Ort
    In mein Haus.
    Beiträge
    1.595

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

    @theSplit: Hat ein bischen gedauert

    Zitat Zitat von theSplit Beitrag anzeigen
    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.

    Zitat Zitat von theSplit Beitrag anzeigen
    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.



    Zitat Zitat von theSplit Beitrag anzeigen
    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)

  17. #17
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Zitat Zitat von DandG Beitrag anzeigen
    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.
    Für diesen Beitrag bedankt sich DandG
    Geändert von theSplit (18.04.20 um 20:37 Uhr)

  18. #18

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

    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 PayLoadTimer.py pfad/zum/spiele/binary 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.

    Code (Python):
    1. $ pylint-3 payloadtimer.py
    2. ************* Module payloadtimer
    3. payloadtimer.py:8:2: W1401: Anomalous backslash in string: '\G'. String constant might be missing an r prefix. (anomalous-backslash-in-string)
    4. payloadtimer.py:8:8: W1401: Anomalous backslash in string: '\M'. String constant might be missing an r prefix. (anomalous-backslash-in-string)
    5. payloadtimer.py:2:0: C0303: Trailing whitespace (trailing-whitespace)
    6. payloadtimer.py:5:0: C0303: Trailing whitespace (trailing-whitespace)
    7. payloadtimer.py:9:0: C0303: Trailing whitespace (trailing-whitespace)
    8. payloadtimer.py:19:0: C0303: Trailing whitespace (trailing-whitespace)
    9. payloadtimer.py:22:0: C0303: Trailing whitespace (trailing-whitespace)
    10. payloadtimer.py:24:0: C0303: Trailing whitespace (trailing-whitespace)
    11. payloadtimer.py:27:0: C0303: Trailing whitespace (trailing-whitespace)
    12. payloadtimer.py:30:0: C0303: Trailing whitespace (trailing-whitespace)
    13. payloadtimer.py:33:0: C0303: Trailing whitespace (trailing-whitespace)
    14. payloadtimer.py:43:0: C0303: Trailing whitespace (trailing-whitespace)
    15. payloadtimer.py:50:0: C0303: Trailing whitespace (trailing-whitespace)
    16. payloadtimer.py:59:0: C0303: Trailing whitespace (trailing-whitespace)
    17. payloadtimer.py:61:0: C0303: Trailing whitespace (trailing-whitespace)
    18. payloadtimer.py:62:0: C0303: Trailing whitespace (trailing-whitespace)
    19. payloadtimer.py:71:0: C0303: Trailing whitespace (trailing-whitespace)
    20. payloadtimer.py:74:0: C0303: Trailing whitespace (trailing-whitespace)
    21. payloadtimer.py:78:0: C0301: Line too long (123/100) (line-too-long)
    22. payloadtimer.py:80:0: C0303: Trailing whitespace (trailing-whitespace)
    23. payloadtimer.py:84:0: C0303: Trailing whitespace (trailing-whitespace)
    24. payloadtimer.py:1:0: C0114: Missing module docstring (missing-module-docstring)
    25. payloadtimer.py:14:0: C0413: Import "from os import stat, path, fstat" should be placed at the top of the module (wrong-import-position)
    26. payloadtimer.py:15:0: C0413: Import "from glob import glob" should be placed at the top of the module (wrong-import-position)
    27. payloadtimer.py:16:0: C0413: Import "from time import sleep, time" should be placed at the top of the module (wrong-import-position)
    28. payloadtimer.py:17:0: C0413: Import "from json import dump, dumps" should be placed at the top of the module (wrong-import-position)
    29. payloadtimer.py:18:0: C0413: Import "import os" should be placed at the top of the module (wrong-import-position)
    30. payloadtimer.py:20:0: C0413: Import "import signal" should be placed at the top of the module (wrong-import-position)
    31. payloadtimer.py:23:0: C0103: Constant name "fileData" doesn't conform to UPPER_CASE naming style (invalid-name)
    32. payloadtimer.py:25:0: C0103: Function name "getFolders" doesn't conform to snake_case naming style (invalid-name)
    33. payloadtimer.py:25:0: C0103: Argument name "rootFolder" doesn't conform to snake_case naming style (invalid-name)
    34. payloadtimer.py:25:0: C0116: Missing function or method docstring (missing-function-docstring)
    35. payloadtimer.py:28:0: C0103: Function name "getFileAtime" doesn't conform to snake_case naming style (invalid-name)
    36. payloadtimer.py:28:0: C0103: Argument name "targetFile" doesn't conform to snake_case naming style (invalid-name)
    37. payloadtimer.py:28:0: C0116: Missing function or method docstring (missing-function-docstring)
    38. payloadtimer.py:31:0: C0103: Function name "getFileSize" doesn't conform to snake_case naming style (invalid-name)
    39. payloadtimer.py:31:0: C0103: Argument name "targetFile" doesn't conform to snake_case naming style (invalid-name)
    40. payloadtimer.py:31:0: C0116: Missing function or method docstring (missing-function-docstring)
    41. payloadtimer.py:34:0: C0103: Function name "noteChanges" doesn't conform to snake_case naming style (invalid-name)
    42. payloadtimer.py:34:0: C0103: Argument name "fileDataKeys" doesn't conform to snake_case naming style (invalid-name)
    43. payloadtimer.py:34:0: C0103: Argument name "fileData" doesn't conform to snake_case naming style (invalid-name)
    44. payloadtimer.py:34:0: C0103: Argument name "outputFileName" doesn't conform to snake_case naming style (invalid-name)
    45. payloadtimer.py:34:0: C0116: Missing function or method docstring (missing-function-docstring)
    46. payloadtimer.py:34:16: W0621: Redefining name 'fileDataKeys' from outer scope (line 86) (redefined-outer-name)
    47. payloadtimer.py:34:30: W0621: Redefining name 'fileData' from outer scope (line 23) (redefined-outer-name)
    48. payloadtimer.py:34:40: W0621: Redefining name 'outputFileName' from outer scope (line 83) (redefined-outer-name)
    49. payloadtimer.py:36:12: C0103: Variable name "fileEntry" doesn't conform to snake_case naming style (invalid-name)
    50. payloadtimer.py:37:12: C0103: Variable name "accessTime" doesn't conform to snake_case naming style (invalid-name)
    51. payloadtimer.py:46:4: C0103: Variable name "e" doesn't conform to snake_case naming style (invalid-name)
    52. payloadtimer.py:48:42: C0103: Variable name "outputFile" doesn't conform to snake_case naming style (invalid-name)
    53. payloadtimer.py:52:16: C0103: Variable name "jsonData" doesn't conform to snake_case naming style (invalid-name)
    54. payloadtimer.py:53:16: C0103: Variable name "jsonData" doesn't conform to snake_case naming style (invalid-name)
    55. payloadtimer.py:54:16: C0103: Variable name "removalString" doesn't conform to snake_case naming style (invalid-name)
    56. payloadtimer.py:55:16: C0103: Variable name "jsonData" doesn't conform to snake_case naming style (invalid-name)
    57. payloadtimer.py:60:8: R1722: Consider using sys.exit() (consider-using-sys-exit)
    58. payloadtimer.py:46:4: W0612: Unused variable 'e' (unused-variable)
    59. payloadtimer.py:63:0: C0103: Function name "fillFileData" doesn't conform to snake_case naming style (invalid-name)
    60. payloadtimer.py:63:0: C0103: Argument name "srcFolder" doesn't conform to snake_case naming style (invalid-name)
    61. payloadtimer.py:63:0: C0116: Missing function or method docstring (missing-function-docstring)
    62. payloadtimer.py:64:4: W0621: Redefining name 'fileData' from outer scope (line 23) (redefined-outer-name)
    63. payloadtimer.py:64:4: C0103: Variable name "fileData" doesn't conform to snake_case naming style (invalid-name)
    64. payloadtimer.py:73:8: C0103: Variable name "folderFiles" doesn't conform to snake_case naming style (invalid-name)
    65. payloadtimer.py:75:12: C0103: Variable name "fileEntry" doesn't conform to snake_case naming style (invalid-name)
    66. payloadtimer.py:76:12: C0103: Variable name "accessTime" doesn't conform to snake_case naming style (invalid-name)
    67. payloadtimer.py:77:12: C0103: Variable name "fileSize" doesn't conform to snake_case naming style (invalid-name)
    68. payloadtimer.py:82:0: C0103: Constant name "baseFolder" doesn't conform to UPPER_CASE naming style (invalid-name)
    69. payloadtimer.py:83:0: C0103: Constant name "outputFileName" doesn't conform to UPPER_CASE naming style (invalid-name)
    70. payloadtimer.py:85:0: C0103: Constant name "fileData" doesn't conform to UPPER_CASE naming style (invalid-name)
    71. payloadtimer.py:86:0: C0103: Constant name "fileDataKeys" doesn't conform to UPPER_CASE naming style (invalid-name)
    72. payloadtimer.py:14:0: W0611: Unused fstat imported from os (unused-import)
    73.  
    74. ------------------------------------
    75. Your code has been rated at -1.48/10
    EDIT: habe das Tool über Guild Wars 2 laufen lassen.

    Code:
    1.  
    2. {"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}
    Code (Bash):
    1. $ tree
    2. .
    3. ├── ArenaNet.log
    4. ├── bin64
    5. ** ├── CoherentUI64.dll
    6. ** ├── CoherentUI_Host.exe
    7. ** ├── d3dcompiler_43.dll
    8. ** ├── ffmpegsumo.dll
    9. ** ├── icudt.dll
    10. ** ├── libEGL.dll
    11. ** ├── libGLESv2.dll
    12. ** └── locales
    13. ├── Crash.dmp
    14. ├── GW2-64.dxvk-cache
    15. ├── GW2-64.exe
    16. ├── GW2-64.tmp
    17. ├── Gw2.dat
    18. ├── Gw2.tmp
    19. └── THIRDPARTYSOFTWAREREADME.txt
    Geändert von rexcolo (18.04.20 um 19:58 Uhr)

  19. #19
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    @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?
    Geändert von theSplit (18.04.20 um 22:06 Uhr)

  20. #20

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

    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.

  21. #21
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Zitat Zitat von rexcolo Beitrag anzeigen
    Habe alles mit Symlinks verschoben und WINE meckert nicht, dafür SELinux.
    Wie meinst du dass Wine meckert nicht, dafür (meckert) 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.
    Dass ist die Frage, wie viel MB aus der Datei immer geladen werden müssen, große Chunks ergibt einen SSD Kandidaten, nur sporadisch ein paar MB könnte auch eine HDD stemmen. Je nachdem wie die Datei verarbeitet wird. Allerdings sehe ich aktuell keine Möglichkeit das irgendwie in Bezug auf Performance her zu messen, leider. Da hilft theoretisch nur testen.

  22. #22
    Zeitreisender

    Administrator

    Avatar von drfuture
    Registriert seit
    Jul 2013
    Ort
    in der Zukunft
    Beiträge
    6.754
    ngb:news Artikel
    17

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

    Die Symbolischen Links arbeiten auf Dateisystem-Ebene. Für Anwendungen die ihre Daten vom Betriebssystem anfordern ist es nicht ersichtlich woher die Daten kommen.
    Daher funktioniert so oder so alles wie zuvor.

    Für "Sicherheits-Programme" egel welcher Art - sieht eine Umleitung natürlich verdächtig aus. Diese Programme prüfen im Zweifel explizit darauf ob die Anfrage an "Datei X" umgeleitet wird und die Daten "irgendwoher" anders abgerufen werden.
    Daher meckert SELinux und im Zweifel auch mal eine andere Sicherheitslösung.
    |_|D *`~{ Ich kenne deine Zukunft }~´* |_|D

  23. #23
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Wir haben nun ein Repository auf Github, Danke drfuture!

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

    Zitat Zitat von DandG Beitrag anzeigen
    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)
    Und im aktuellen Release gibt es neben den Python3 Skripts auch Windows Executables:
    https://github.com/NGB-to/split-that...ases/tag/0.0.1

    Bitte beachtet, der PayLoadTimer.py/exe sucht nach einer src.txt in seinem Verzeichnis um den Ort zum protokollieren zu wählen.
    Für diesen Beitrag bedanken sich sia, rexcolo, DandG
    Geändert von theSplit (19.04.20 um 20:59 Uhr) Grund: Notiz für src.txt

  24. #24
    Freier Denker
    Registriert seit
    Jul 2013
    Beiträge
    511

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

    Das Projekt klingt ganz cool. Vermutlich nicht für Rollenspiele oder sowas, wohl aber für Strategiespiele zum Beispiel. Da muss ja beispielsweise regelmäßig das Objekt eines Fußsoldaten erstellt werden, die allgemeine "Map" aber eher nur einmal zum Spielstart.

    Auch stelle ich mir den Boost in verschiedensten anderen Programmen gut vor.

    Dass am Ende natürlich alles bestenfalls in einer "einfachen" GUI Platz findet und man als Nutzer nur noch zwei Ordner auswählt und sagt "Mach mal" und irgendwann noch einen Klick macht "Bin fertig, schieb mal Kram rum", ist denke ich klar.
    Dann würde ich das zumindest mal bei mir ausprobieren.
    Wichtig wäre mir aber auch eine Funktion wie "mach es rückgängig" - also wo alle Dateien wieder an den korrekten Ort verschoben werden und Symlinks aufgelöst werden. Das bedeutet, dass neben dem Profil für die einzelnen Anwendungen auch noch eine Art von "Ich habe folgendes verschoben und verlinkt"-Liste abgespeichert wird. Das ist natürlich im Zweifel einige KB, vielleicht sogar wenige MB Overhead aber für mich auf alle Fälle wünschenswert.

    Ich habe mir das PayLoadTimer-Skript noch nicht wirklich angeschaut. Speichert das nur einmal am Ende, welche Dateien wie häufig angefragt wurden und ähnliches? Ich könnte mir nämlich auch vorstellen, dass man daraus eine regelrechte Versuchsreihe machen könnte. Folgende Szenarien habe ich da so im Kopf

    1) Das Skript speichert die Anzahl der Zugriffe auf eine Datei, ggf. speichert es auch noch dazu, wie groß diese Datei ist. Dann kann man über einen definierten Threshold entscheiden, wie viel % der Dateien auf die SSD kommen oder auch nicht.

    2) Man zeichnet über mehrere Programm-Nutzungszeiträume Profile auf und hat die Möglichkeit diese mit einem irgendwie gearteten Algorithmus zu analysieren. Beispielsweise kann es ja vorkommen, dass einzelne Dateien nur bei wenigen Nutzungen viele Aufrufe haben, andere dafür aber immer sehr häufig angefragt werden.

    3) Es sollte sich erkundigt werden, ob man auch eine Schnittstelle zu dem OS oder einer anderen naheliegenden Treiberebene hat, in der man auch auslesen kann, welche Teile der Datei gerade geladen wurden. Das würde die Profile zum Analsysieren erstmal ernorm vergrößern. Hierdurch kann man aber sehen, ob einzelne Dateibereiche regelmäßig angefragt werden (ggf HDD), oder aber eine ganze Datei auf einmal geladen werden muss (SSD).

    4) Zudem könnte man als "Analyse" auch überlegen, ob es Sinn macht ein Vortrainiertes Neuronales Netz am Ende an den Nutzer auszuliefern, dass die Auswertung der Profile übernimmt und dabei die "beste Performance" ausgibt. Die Frage ist natürlich in wie weit jemand da eine Testreihe durchführen möchte und dort ein entsprechendes Netz (a) entwerfen und (b) trainieren möchte.

    5) Es wäre vermutlich auch interessant zu wissen, in welchen zeitlichen Abständen die Zugriffe auf die Datei durchgeführt wurden. Viele Zugriffe zeitlich nah beieinander sprechen eher für eine SSD, viele Zugriffe, dafür aber mit größeren Pausen, sprechen für HDD. Entsprechendes sollte auch in den Profildaten enthalten sein.

    ---
    Jetzt sind die Szenarien mit irgendwelchen Ideen, die mir im Kopf rumgeschwirt sind vermischt. Viel Spaß beim Querlesen und Kopfschütteln. Vielleicht habe ich ja schon einen sinnvollen Beitrag geleistet.

    ---
    Bezüglich Programmierer die dabei mitmachen. Ich werde zumindest mal in das Repo schauen und jenachdem, wie das hier weiter voran geht auch mal was beitragen - vielleicht aber auch nur Hinweise auf mögliche Probleme oder dergleichen geben. Ich bin (noch) nicht so sehr vertraut mit dieser Art der Projektumsetzung und halte mich da lieber etwas zurück.

  25. #25
    since 1998

    Moderator

    (Threadstarter)

    Avatar von theSplit
    Registriert seit
    Aug 2014
    Beiträge
    25.380
    ngb:news Artikel
    4

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

    Zitat Zitat von Roin Beitrag anzeigen
    Das Projekt klingt ganz cool. Vermutlich nicht für Rollenspiele oder sowas, wohl aber für Strategiespiele zum Beispiel. Da muss ja beispielsweise regelmäßig das Objekt eines Fußsoldaten erstellt werden, die allgemeine "Map" aber eher nur einmal zum Spielstart.
    Ich glaube man muß das sehr individuell sehen ob ein Titel mehr Daten dann vorlädt und evnetuell nachlädt bzw. ständig darauf zugreift.

    Auch stelle ich mir den Boost in verschiedensten anderen Programmen gut vor.
    Das wäre das Ideal.


    Wichtig wäre mir aber auch eine Funktion wie "mach es rückgängig" - also wo alle Dateien wieder an den korrekten Ort verschoben werden und Symlinks aufgelöst werden. Das bedeutet, dass neben dem Profil für die einzelnen Anwendungen auch noch eine Art von "Ich habe folgendes verschoben und verlinkt"-Liste abgespeichert wird. Das ist natürlich im Zweifel einige KB, vielleicht sogar wenige MB Overhead aber für mich auf alle Fälle wünschenswert.
    Indirekt ist das schon geplant, ich dachte an eine SQLite Schnittstelle für diese Informationen, wobei aber Profile bzw. Presets als Dateien vorliegen sollen, andere Settings zur Nutzung aber in der Datenbank, so in etwa. Das ist vor allem wichtig, da Windows ein Limit hat wie viele auf einmal verlinkt werden darf, 63 "Punkte" sind das Limit pro Verzeichnis und eventuell gilt das auch für Unterordner in dem gleichen Pfad.Das ist aber verlinkt. Daher wäre es wichtig die Symlink an und abschalten zu können um innerhalb dieses Limits zu bleiben. (Habe ich verlinkt.)

    Ich habe mir das PayLoadTimer-Skript noch nicht wirklich angeschaut. Speichert das nur einmal am Ende, welche Dateien wie häufig angefragt wurden und ähnliches? Ich könnte mir nämlich auch vorstellen, dass man daraus eine regelrechte Versuchsreihe machen könnte. Folgende Szenarien [...]
    Ja, es speichert die Anzahl der Zugriffe, per Standard jetzt alle 30 Sekunden - werden die Daten auf Zugriffe überprüft und die Zeiten der Zugriffe. Außerdem wird der Pfad und die Größe gespeichert. Eventuell könnte man auch die Größe während des Zugriffs in Byte messen lassen.

    [...] habe ich da so im Kopf.

    1) Das Skript speichert die Anzahl der Zugriffe auf eine Datei, ggf. speichert es auch noch dazu, wie groß diese Datei ist. Dann kann man über einen definierten Threshold entscheiden, wie viel % der Dateien auf die SSD kommen oder auch nicht.
    Um das zu vereinfachen habe ich an ein "Scoring" System gedacht von 0 bis 10 gedacht. So kann man bewerten wie "dringend" eine Datei benötigt wird und dann einen Threshold nutzen. Also 10 wird viel/oft geladen, 0 wird nur einmal geladen. Die Punkte soll man aber selbst vergeben können. Zum Beispiel kann es sein das bei einem Rollenspiel ein Spielgebiet öfter geladen wird bei einem User, bei einem anderen gar nicht wirklich in der Messung auftaucht. Daher wäre hier ein einfaches System wünscheswert. Wenn du da ne Idee hast?

    Auch bezogen auf deinen Punkt 2 hier:
    2) Man zeichnet über mehrere Programm-Nutzungszeiträume Profile auf und hat die Möglichkeit diese mit einem irgendwie gearteten Algorithmus zu analysieren. Beispielsweise kann es ja vorkommen, dass einzelne Dateien nur bei wenigen Nutzungen viele Aufrufe haben, andere dafür aber immer sehr häufig angefragt werden.
    3) Es sollte sich erkundigt werden, ob man auch eine Schnittstelle zu dem OS oder einer anderen naheliegenden Treiberebene hat, in der man auch auslesen kann, welche Teile der Datei gerade geladen wurden. Das würde die Profile zum Analsysieren erstmal ernorm vergrößern. Hierdurch kann man aber sehen, ob einzelne Dateibereiche regelmäßig angefragt werden (ggf HDD), oder aber eine ganze Datei auf einmal geladen werden muss (SSD).
    Ebenfalls ein guter Punkt, da hab ich aber selbst noch keine Lösung zu gefunden ohne sich irgendwie einzu"häcken", eventuell helfen unter Windows die SysInternals Tools - wie SysMon oder ProcMon - da bin ich unschlüssig wie das analysiert werden kann.

    4) Zudem könnte man als "Analyse" auch überlegen, ob es Sinn macht ein Vortrainiertes Neuronales Netz am Ende an den Nutzer auszuliefern, dass die Auswertung der Profile übernimmt und dabei die "beste Performance" ausgibt. Die Frage ist natürlich in wie weit jemand da eine Testreihe durchführen möchte und dort ein entsprechendes Netz (a) entwerfen und (b) trainieren möchte.
    Naja, der Logik her gibt "Größe in Bytes, Häufigkeit" aktuell so die Idee, den Maßstab vor. Auch auf Punkt 3 bezogen. Sicherlich kann man da was "beratendes" entwerfen, was das einbezieht - zum Beispiel wenn man als Grenze seine Hardware "GB RAM, GB RAM Graifkkarte" angibt?

    5) Es wäre vermutlich auch interessant zu wissen, in welchen zeitlichen Abständen die Zugriffe auf die Datei durchgeführt wurden. Viele Zugriffe zeitlich nah beieinander sprechen eher für eine SSD, viele Zugriffe, dafür aber mit größeren Pausen, sprechen für HDD. Entsprechendes sollte auch in den Profildaten enthalten sein.
    Das wäre über die Score geregelt, das man sagen kann wie viel Punkte man "investieren will", "wie viel MB/GB dass ergeben und ob das mit den Regeln/Limits der Symlinks vereinbar ist.

    ---
    Jetzt sind die Szenarien mit irgendwelchen Ideen, die mir im Kopf rumgeschwirt sind vermischt. Viel Spaß beim Querlesen und Kopfschütteln. Vielleicht habe ich ja schon einen sinnvollen Beitrag geleistet.
    ---
    Passt, und ich hoffe ich konnte dir ein paar deinen Punkte und Fragen beantworten.

    Bezüglich Programmierer die dabei mitmachen. Ich werde zumindest mal in das Repo schauen und jenachdem, wie das hier weiter voran geht auch mal was beitragen - vielleicht aber auch nur Hinweise auf mögliche Probleme oder dergleichen geben. Ich bin (noch) nicht so sehr vertraut mit dieser Art der Projektumsetzung und halte mich da lieber etwas zurück.
    No need to be shy

    Edit: Es kommt nicht darauf an das die erste Lösung perfekt ist und oder alle Punkte umfasst - man lernt ja dazu und wenn erst mal was steht, um so mehr sicherlich. Also auch für Neueinsteiger eventuell geeignet weil es wenige bis keine Abhängigkeiten gibt.
    Für diesen Beitrag bedankt sich Roin
    Geändert von theSplit (24.04.20 um 22:05 Uhr)

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •