Techniken zum Teilen veränderlicher Daten zwischen Rust und Python mit PyO3

Fazit (Conclusion)

Dass PyO3 Strukturen, die Rust-Lifetimes verwenden, nicht direkt in Python exponieren kann, mag zunächst wie eine Einschränkung wirken. Rusts Standardbibliothek und PyO3 bieten jedoch leistungsstarke Werkzeuge, um diese Grenze zu überwinden. std::mem::take und std::mem::replace ermöglichen den geschickten Umgang mit veränderlichen Referenzen (mutable reference) und besessenen Werten (owned value), während Arc und Mutex äußerst nützlich sind, um gemeinsam genutzte veränderliche Daten in Python verfügbar zu machen. Besonders MutexExt von PyO3 ist ein unverzichtbares Werkzeug, um Deadlocks zu vermeiden, wenn Mutexes zusammen mit Python verwendet werden.

---

Zusammenfassung der wichtigsten Inhalte

Dieses Dokument erklärt Schritt für Schritt die technischen Probleme, die beim Teilen veränderlicher (mutable) Daten zwischen Rust und Python in einem Projekt zur Reimplementierung der Django-Template-Sprache in Rust aufgetreten sind, sowie den Lösungsweg dafür.

• Hintergrund: Die Django-Template-Sprache stellt Templates über ein Objekt namens context dynamische Daten bereit. In der Rust-Implementierung des Projekts wurde dieser context als Rust-Struktur definiert und muss beim Rendern von Template-Tags als veränderliche Referenz (&mut Context) übergeben werden.

• Anfängliches Problem: Die veränderliche Referenz (&mut Context) aus dem Rust-Code muss zur Ausführung benutzerdefinierter Tags an eine Python-Funktion übergeben werden. Python versteht jedoch Rust-Lifetimes nicht, und PyO3, die Bibliothek zur Rust-Python-Integration, verlangt besessene Werte (owned value). Wird die Referenz direkt übergeben, führt das zu einem Compiler-Fehler.

• Lösungsweg:

  1. Lösung des Ownership-Problems: Mit std::mem::take wird vorübergehend die Ownership aus &mut Context übernommen, um ein besessenes Context-Objekt zu erzeugen, das an Python übergeben werden kann. Nach der Ausführung des Python-Codes wird versucht, den verarbeiteten Context mit std::mem::replace wieder an seine ursprüngliche Referenzposition zurückzuschreiben.
  2. Lösung des Fehlers „Moved Value“: Dabei tritt jedoch ein Compiler-Fehler vom Typ „use of moved value“ auf, wenn das Context-Objekt nach dem Move in die Python-Funktion erneut verwendet werden soll. Zur Lösung dieses Problems wird Arc (Atomic Reference Count) eingeführt, das Context umschließt. So kann Python ein geklonter Verweis (clone) übergeben werden, ohne die Ownership zu verschieben.
  3. Umgang damit, wenn Python die Referenz behält: Wenn Python weiterhin eine Referenz auf Context hält, kann die Rückgewinnung der Ownership über Arc::try_unwrap fehlschlagen. In diesem Fall wird eine Fallback-Methode wie clone_ref implementiert, die die internen Daten von Context per Deep Copy klont.
  4. Änderungen der Daten in Python erlauben: Abschließend wird Mutex eingeführt, damit der Python-Code Context nicht nur lesen, sondern auch verändern kann. Mit der Struktur Arc<Mutex<Context>> wird sichergestellt, dass mehrere Threads sicher auf die Daten zugreifen und sie ändern können. Um Deadlocks mit dem Python-Interpreter zu vermeiden, wird dabei die von PyO3 bereitgestellte Methode lock_py_attached aus MutexExt verwendet.