Figure 6.9: Calling a Method

1. Diagrammtyp & Architektur-Kontext

• Klassifikation: UML-Sequenzdiagramm mit Aufteilung in zwei Sprachdomänen (Rust und C++), asynchronem Kontrollfluss und FFI-Übergang (Foreign Function Interface).
• Technischer Zweck: Spezifikation des interoperablen Dienstaufruf-Musters (Method Invocation) in der AUTOSAR Adaptive Platform (ARA) für Rust-Applikationen. Es visualisiert das Mapping zwischen dem kooperativen, waker-basierten Asynchronitätsmodell von Rust (Future, async/await, Channels) und dem callback-/future-basierten Modell des klassischen C++-ARA-Stacks (ara::core::Future, .then()).

2. Komponenten, Entitäten & Schnittstellen

Das Diagramm gliedert sich strikt entlang der Sprachgrenze:

Rust-Domäne

• Executor: Asynchroner Task-Scheduler der Rust-Laufzeitumgebung (z. B. Tokio- oder systemnahe deterministische Task-Queue), der blockierungsfrei zwischen Tasks wechselt, sobald ein Poll::Pending signalisiert wird.
• App: Die funktionale Adaptive Application (AA), implementiert in Rust, welche die ara::com-Dienstschnittstelle konsumiert.
• Proxy (gen): Generierter typsicherer Rust-Service-Proxy (aus ARXML-Service-Interfaces erzeugt), der der Applikation idiomatische Rust-APIs (async fn) bereitstellt.
• ara crate: Statische Laufzeit-Bibliothek/Crate des AUTOSAR-Rust-Stacks. Kapselt generische Inter-Task-Kommunikation, Asynchronitäts-Primitive (Channel-Erzeugung, Waker-Registrierung) und grundlegendes FFI-Handling.

C++-Domäne

• Adapter (gen): Generierter C-kompatibler FFI-Wrapper/Brückencode. Entpackt C-ABI-Parameter aus Rust und vermittelt typkonvertiert an die C++-Objektmethoden.
• Adapter (static): Statische Laufzeitkomponente der C++-Brücke, zuständig für generische Callback-Bindungen, C++-Lambdas und Lebensdauer-Management von Kontextdaten über Sprachgrenzen hinweg.
• Proxy (gen): Standardmäßiger AUTOSAR-Adaptive C++-Service-Proxy (ara::com), der die Serialisierung (z. B. SOME/IP, IPC) und die Interaktion mit dem Kommunikations-Daemon/Netzwerk vornimmt.

3. Dynamisches Verhalten & Sequenzablauf

Phase 1: Initiierung des Methodenaufrufs (Synchroner Forward-Pfad über FFI)

1. Methodenaufruf: App initiiert Calibrate(...) am generierten Rust-Proxy (gen).
2. Channel-Setup: Proxy (gen) delegiert an ara crate::call_method, woraufhin ara crate einen internen Einweg-/Oneshot-Channel zur Ergebnisübertragung erzeugt (Create channel) und eine closure zurückliefert.
3. FFI-Übergang: Proxy (gen) ruft über C-ABI synchron Calibrate am C++-Adapter (gen) auf.
4. Adapter-Kaskade: Adapter (gen) konsultiert Adapter (static)::ProxyCallMethod, erhält eine lambda-Definition und ruft die C++-Methode Calibrate am C++-Proxy (gen) auf.
5. Netzwerkübertragung & Future: C++-Proxy (gen) versendet den Aufruf (Send call to network) und gibt synchron ein ara::core::Future an den Adapter (gen) zurück.
6. Callback-Registrierung: Adapter (gen) bindet via register .then() callback die Continuation an das C++-Future. Der synchrone Aufruf kehrt über die FFI-Grenze nach Rust zurück.

Phase 2: Asynchrones Suspendieren in Rust

1. Channel-Await: Proxy (gen) initiiert await channel auf dem erzeugten Kanal der ara crate.
2. App-Suspendierung: Der Kontrollfluss kehrt via await call_method zur App zurück; App signalisiert await Calibrate an den Executor.
3. Task-Switch: Der Rust-Executor suspendiert die Calling-Task (Switch to other tasks) und gibt den Thread für andere Arbeitslasten frei.

Phase 3: Asynchrone Antwort, Cross-Domain-Callback & Waker-Signalisierung

1. Antwortempfang: C++-Proxy (gen) empfängt die Antwort (Result from network) und triggert den registrierten .then() callback.
2. Cross-Language Notification: Adapter (static) ruft über einen C-ABI-Funktionszeiger method_callback in der Rust-ara crate auf.
3. Waker-Aktivierung: ara crate transferiert die Payload (Send result to channel) und triggert channel wake am Rust-Executor.
4. Task-Reaktivierung: Der Executor führt ein Async resume der App-Task aus.
5. Ergebnisübernahme: App fragt Proxy (gen) ab, dieser ruft Receive result auf der ara crate ab, und das deserialisierte Result wird typsicher an die App übergeben.

4. Normative Relevanz & Entwickler-Hinweise

• Zero-Blocking FFI-Anforderung: Der FFI-Wechsel von Rust nach C++ (Proxy (gen) → Adapter (gen)) ist strikt nicht-blockierend. C++-Treiber bzw. der C++-ara::com-Proxy dürfen innerhalb des Aufrufs niemals blockierend synchron auf Netzwerkantworten warten, sondern müssen unverzüglich ein ara::core::Future retournieren.
• Lebensdauer- & Speichersicherheit: Das Mapping zwischen Rust-Future/Channel und C++-Lambda erfordert stabile Speicherreferenzen. Der Rückkanal (method_callback) muss zwingend Context-Handles (z. B. rohe Pointer auf Waker/State oder Token) verwalten, die gegen Use-after-free bei Task-Abbrüchen/Timeouts abgesichert sind.
• Threading-Modell: Der C++-.then()-Callback feuert üblicherweise im Kontext des IPC-/Network-Worker-Threads. Der Aufruf von channel wake überschreitet daher Thread-Grenzen und muss thread-sicher (Send + Sync) implementiert sein, ohne den C++-Thread mit Rust-Task-Arbeit zu blockieren.
• Fehlerbehandlung: Kommunikations- und Applikationsfehler (ara::core::ErrorCode) müssen auf Ebene der generierten Adapter verlustfrei in Rust-Idiome (Result<T, ara::core::Error>) transformiert werden.