← C++

C++ · 09 / 24

Hintergrundarbeit, Performance und Desktop-Pakete

Du beobachtest einen stoppbaren Simulationsdienst und prüfst die App als messbare, auslieferbare Software.

  • Groß
  • Anspruchsvoll
  • 120 min

Voraussetzungen: Klassen, Referenzen, const und RAII, Header, CMake und erste Unit-Tests, A*-Wegfindung und deterministische Transportsimulation

In diesem Tutorial
  1. Das Beispiel und seine Abhängigkeiten bauen
  2. Pause und Einzelschritt überprüfen
  3. Hintergrundlauf und Zustandskopien lesen
  4. Den Dienst geordnet stoppen
  5. Performance mit einem konkreten Szenario messen
  6. Die Prüfung nachvollziehen
  7. Ein Paket auf der Zielplattform prüfen
  8. Übung und Lösung
  9. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20 und CMake ab 3.25. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Geprüft am 21.10.2026 unter Linux x86_64. Der echte Simulationsdienst wird gestartet und gestoppt. Die Lösung wiederholt Pause, Einzelschritt und Stop zwanzigmal. Windows-Auslieferung bleibt ungeprüft.

Ein Fenster muss während der Berechnung weiter auf Eingaben reagieren. Die fertige App verwendet deshalb einen Hintergrunddienst. Threads teilen sich den Speicher desselben Prozesses. Das macht die Übergabe von Zuständen möglich, verlangt aber eine klare Regel für gleichzeitigen Zugriff. Ein Mutex schützt hier Simulation und Zustandskopien.

std::jthread unterstützt einen geordneten Stopp über stop_token. Ein Stoppwunsch beendet Arbeit nicht magisch. Der Worker muss ihn beobachten und seine Wartestelle muss aufwachen können. Diese Lektion benutzt den echten SimulationService. Das Beispiel prüft zunächst Einzelschritte und lässt den restlichen Auftrag anschließend im Hintergrund abschließen.

Paketinhalt und einzelne Dateien

01Das Beispiel und seine Abhängigkeiten bauen

Entpacke das Lernpaket. Die benötigten FactoryForge-Dateien liegen unter vendor und stammen aus dem verlinkten festen Quellstand. cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug und cmake --build build bauen das eigenständige Beispiel. Das vollständige Projekt-ZIP ist für diese Prüfung nicht zusätzlich nötig.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.25)
project(ThreadLesson LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
get_filename_component(FACTORYFORGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vendor/factory-forge" ABSOLUTE CACHE)
find_package(Threads REQUIRED)
add_executable(lesson main.cpp
  "${FACTORYFORGE_SOURCE_DIR}/src/core/project.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/core/pathfinder.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/core/puzzles.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/core/simulation.cpp"
  "${FACTORYFORGE_SOURCE_DIR}/src/application/simulation_service.cpp")
target_include_directories(lesson PRIVATE "${FACTORYFORGE_SOURCE_DIR}/include")
target_link_libraries(lesson PRIVATE Threads::Threads)

02Pause und Einzelschritt überprüfen

start erhält eine Musterlösung und false als Startzustand. Der Dienst besitzt eine Simulation, führt aber noch keine automatischen Schritte aus. Zwanzig Aufrufe von stepOnce ergeben exakt zwanzig logische Ticks. Das ist eine überprüfbare fachliche Aussage und hängt nicht davon ab, wie schnell der Rechner die Schleife ausführt.

main.cpp · cppDatei öffnen
#include "factory/application/simulation_service.h"
#include "factory/core/puzzles.h"
#include <chrono>
#include <iostream>
#include <thread>
int main() {
  factory::SimulationService service;
  service.start(factory::makePuzzle(0, true), false);
  for (int i = 0; i < 20; ++i)
    service.stepOnce();
  std::cout << "manual_ticks=" << service.snapshot().tick << '\n';
  service.setSpeed(4);
  service.setPlaying(true);
  const auto deadline =
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
  while (service.snapshot().outcome == factory::Outcome::Running &&
         std::chrono::steady_clock::now() < deadline)
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
  const auto snapshot = service.snapshot();
  service.stop();
  std::cout << "delivered=" << snapshot.delivered << '\n';
  std::cout << std::boolalpha << "stopped=" << !service.active() << '\n';
  return snapshot.outcome == factory::Outcome::Won ? 0 : 1;
}

Starten / prüfen

cmake -S . -B build -G Ninja -DFACTORYFORGE_SOURCE_DIR=/path/to/factory-forge
cmake --build build
./build/lesson
Erwartetes Ergebnis

manual_ticks=20

03Hintergrundlauf und Zustandskopien lesen

setSpeed(4) und setPlaying(true) starten die automatische Fortsetzung. snapshot liefert einen geschützten Wert. Der Aufrufer darf diese Kopie lesen, ohne in die laufenden Fahrzeugdaten zu schreiben. Die kurze Wartezeit im Lernprogramm verhindert eine aktive Dauerschleife. Die zusätzliche Frist verhindert, dass ein fehlerhaftes Beispiel unbegrenzt wartet.

04Den Dienst geordnet stoppen

stop fordert den Stopp an, weckt die Bedingungsvariable und wartet auf das Ende des Threads. Erst anschließend wird die Simulation freigegeben. join darf nicht unter einem Mutex laufen, den der Worker noch zum Beenden benötigt. Starte das Beispiel und prüfe neben den Ticks auch Lieferung und Lebensdauer.

Erwartetes Ergebnis

manual_ticks=20 delivered=3 stopped=true

05Performance mit einem konkreten Szenario messen

Baue die App im Release-Modus und starte factoryforge-cli --benchmark 50. Der Bericht enthält Szenario, Anzahl, Lieferungen, mittlere und maximale Schrittzeit. Die mitgelieferte Messung schließt Darstellung und Echtzeit-Warten aus. Vergleiche denselben Build und denselben Rechner. Eine einzelne schnelle Demo beweist keine garantierte Leistung für beliebige Karten.

06Die Prüfung nachvollziehen

Der echte Simulationsdienst wird gestartet und gestoppt. Die Lösung wiederholt Pause, Einzelschritt und Stop zwanzigmal. Windows-Auslieferung bleibt ungeprüft. Starte python3 run_checks.py aus dem entpackten Paket. Vergleiche die Test-Erwartungen mit der Übung, bevor du die Lösung öffnest.

Erwartetes Ergebnis

Beispiel und automatisierte Lösung bestehen. Die genannten manuellen Prüfungen bleiben getrennt.

07Ein Paket auf der Zielplattform prüfen

Das Linux-Paket enthält App, CLI, Qt-Laufzeit, Puzzle-Dateien und Lizenztexte. Der Launcher setzt relative Bibliothekspfade. Der Windows-Helfer verwendet windeployqt und die vorbereitete native Build-Matrix. Ein kompiliertes Programm ist noch kein geprüftes Paket. Starte die gebündelte App und den gebündelten Konsolenlauf. Der Windows-Nachweis bleibt bis zu einer echten Windows-Prüfung offen.

Deine Übung

Starte den Dienst mehrmals, pausiere, führe einen Schritt aus und stoppe ihn. Vergleiche außerdem einen Debug- und einen Release-Benchmark, ohne daraus einen allgemeinen Geschwindigkeitsfaktor abzuleiten.

Lösung mit Erklärung anzeigen

Jeder neue Lauf beginnt beim Ausgangsaufbau. In Pause verändert sich die Tickzahl ohne Einzelschritt nicht. stop beendet den Worker und active ist danach falsch. Der vorhandene Anwendungstest wiederholt diesen Ablauf zwanzigmal. Performance-Vergleiche werden mit Build-Typ, Hardware und Szenario dokumentiert. Sie erklären eine Beobachtung und ersetzen keine Prüfung auf der Zielplattform.

solution/main.cpp · cppDatei öffnen
#include "factory/application/simulation_service.h"
#include "factory/core/puzzles.h"
#include <cassert>
#include <chrono>
#include <iostream>
#include <thread>
int main() {
  factory::SimulationService service;
  for (int run = 0; run < 20; ++run) {
    service.start(factory::makePuzzle(0, true), false);
    assert(service.snapshot().tick == 0);
    service.stepOnce();
    const auto paused = service.snapshot().tick;
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    assert(service.snapshot().tick == paused);
    service.stop();
    assert(!service.active());
  }
  service.start(factory::makePuzzle(0, true), false);
  for (int i = 0; i < 20; ++i)
    service.stepOnce();
  std::cout << "manual_ticks=" << service.snapshot().tick << '\n';
  service.setSpeed(4);
  service.setPlaying(true);
  const auto deadline =
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
  while (service.snapshot().outcome == factory::Outcome::Running &&
         std::chrono::steady_clock::now() < deadline)
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
  const auto snapshot = service.snapshot();
  service.stop();
  std::cout << "delivered=" << snapshot.delivered << '\n';
  std::cout << std::boolalpha << "stopped=" << !service.active() << '\n';
  return snapshot.outcome == factory::Outcome::Won ? 0 : 1;
}

Projektbezug und Quellen

Die ersten sechs Beispiele sind eigenständige Lernprogramme. Lektionen 7 bis 9 nutzen den vollständigen FactoryForge-Quellstand. Quellcode, Übungen und überprüfte Vereinfachungen sind getrennt beschrieben. Die Projektseite bietet ein Quellcode-ZIP, solange das GitHub-Repository noch nicht veröffentlicht ist.