Effiziente Verarbeitung und Analyse von C++-Objekten in Skriptsprachen durch fette API-Bindungen

Core Concepts

Eine fette API ermöglicht es, nahezu alle öffentlichen Attribute und Methoden eines C++-Objekts in einer konsumierenden Umgebung wie einer Skriptsprache oder einem Webbrowser zu exponieren.

Abstract

Der Artikel beschreibt die Verwendung des Classdesc-Systems, um eine Reflexion von C++-Objekten in eine JavaScript/TypeScript-Umgebung über einen REST-Dienst und eine Node.js-API-Komponente zu implementieren.
Die Hauptaspekte sind:

REST-Dienst: Verwendung von HTTP-Verben (GET, PUT, POST, DELETE) zum Lesen, Aktualisieren und Aufrufen von Methoden der C++-Objekte. JSON-Serialisierung für Argumente und Rückgabewerte.

Node.js-API: Direktes Binden der C++-Schicht in den Node.js-Prozess, um Probleme mit plattformspezifischen nativen Fenstern zu umgehen. Asynchrone Aufrufe von C++-Methoden, um die Benutzeroberfläche nicht zu blockieren.

TypeScript: Automatische Generierung von TypeScript-Definitionen aus den C++-Bindungen, um Typprüfungen zur Kompilierzeit zu ermöglichen.

Python: Implementierung einer Python-API unter Verwendung der niedrigeren Python-C-API, anstatt der boost-python-Bibliothek, um Kompatibilität mit dem MXE-Crosscompiler zu erreichen.

Optimierung der Buildzeiten: Verschiedene Techniken wie explizite Instantiierung von Templates, Entfernen von Makros und Reduzierung der Methodenarität werden eingesetzt, um die Kompilier- und Linkzeiten zu verbessern.

Stats

Die Buildzeiten für die verschiedenen Optimierungsstrategien betragen:

GCC, keine Optimierung: 1048 Sekunden
Clang, keine Optimierung: 377 Sekunden
GCC, explizite Instantiierung: 445 Sekunden
Clang, explizite Instantiierung: 287 Sekunden
GCC, entrollte Templates: 427 Sekunden
Clang, entrollte Templates: 291 Sekunden
GCC, Reduzierung der Arität: 409 Sekunden
Clang, Reduzierung der Arität: 284 Sekunden
Die Linkzeiten für verschiedene Linker betragen:

GNU ld: 4 Sekunden
LLVM ld (lld): 3,9 Sekunden
Mold: 0,7 Sekunden
MXE ld.bfd: 791 Sekunden

Quotes

"Eine fette API exponiert nahezu alle öffentlichen Attribute und Methoden eines C++-Objekts in einer konsumierenden Umgebung, wie einer Skriptsprache oder einem Webbrowser."
"Offensichtlich ist Reflexion erforderlich, um C++-Objekte in eine konsumierende Schicht wie diese zu exponieren - dieser Artikel untersucht die Verwendung des Classdesc-Systems, um die Reflexion von C++-Objekten in eine JavaScript/TypeScript-Umgebung über einen REST-Dienst und auch über eine Node.js-API-Komponente zu implementieren."

Key Insights Distilled From

Fat API bindings of C++ objects into scripting languages

by Russell K. S... at arxiv.org 03-25-2024

https://arxiv.org/pdf/2403.14940.pdf

Deeper Inquiries

Wie könnte man die Leistung der fetten API-Bindungen weiter optimieren, insbesondere für Anwendungen mit sehr großen C++-Codebases?

Um die Leistung der fetten API-Bindungen für Anwendungen mit umfangreichen C++-Codebases weiter zu optimieren, könnten mehrere Ansätze verfolgt werden:

Reduzierung der Arity: Durch die Reduzierung der maximalen Anzahl von Argumenten, die an die Methoden übergeben werden können, kann die Komplexität verringert werden. Dies könnte dazu beitragen, die Anzahl der generierten Template-Helferfunktionen zu reduzieren und somit die Kompilierungs- und Linkzeiten zu verkürzen.

Verwendung von speziellen Compileroptimierungen: Bestimmte Compileroptionen oder Optimierungen können die Generierung und Verarbeitung von Template-Code effizienter machen. Dies könnte die Build-Zeiten insgesamt verkürzen.

Explizite Instantiierung von Templates: Durch die explizite Instantiierung von Templates in einem einzigen Kompilierungseinheit können unnötige Duplikate vermieden werden, was zu einer Reduzierung der Linkzeiten führen kann.

Verwendung von effizienteren Linkern: Der Einsatz von modernen und effizienten Linkern wie Mold kann die Linkzeiten erheblich verkürzen, insbesondere für plattformübergreifende Anwendungen.

Welche Herausforderungen und Kompromisse ergeben sich, wenn man eine fette API-Schnittstelle anstelle einer konventionellen, schlanken API-Schnittstelle verwendet?

Die Verwendung einer fetten API-Schnittstelle anstelle einer schlanken API-Schnittstelle bringt sowohl Herausforderungen als auch Kompromisse mit sich:

Herausforderungen:

Komplexität: Eine fette API kann aufgrund der Vielzahl von verfügbaren Methoden und Attributen komplexer sein, was die Wartung und das Verständnis erschweren kann.
Leistungseinbußen: Eine umfangreiche API kann zu Leistungseinbußen führen, insbesondere wenn nicht alle Funktionen effizient implementiert sind.
Build-Zeiten: Die Generierung von umfangreichem Code für die API kann zu längeren Kompilierungs- und Linkzeiten führen.

Kompromisse:

Flexibilität vs. Einfachheit: Eine fettere API bietet mehr Flexibilität für Entwickler, erfordert jedoch möglicherweise mehr Aufwand, um sie zu verstehen und zu nutzen.
Entwicklungszeit vs. Leistung: Die Implementierung einer umfangreichen API kann mehr Zeit in Anspruch nehmen, bietet jedoch möglicherweise eine bessere Leistung und Funktionalität.

Wie könnte man die Konzepte der fetten API-Bindungen auf andere Sprachen oder Plattformen außerhalb von JavaScript/TypeScript und Node.js übertragen?

Um die Konzepte der fetten API-Bindungen auf andere Sprachen oder Plattformen zu übertragen, könnten folgende Schritte unternommen werden:

Anpassung an die Zielsprache: Die Konzepte und Implementierungen der fetten API müssen an die Syntax und Funktionalität der Zielsprache angepasst werden. Dies könnte die Entwicklung spezifischer Bindungsmechanismen oder Bibliotheken umfassen.

Implementierung von Serialisierungsmechanismen: Die Übertragung von Objekten und Methoden zwischen verschiedenen Sprachen erfordert effiziente Serialisierungsmechanismen. Dies könnte die Verwendung von JSON, XML oder anderen Datenformaten umfassen.

Entwicklung von speziellen Bindungswerkzeugen: Die Erstellung von Werkzeugen oder Bibliotheken, die die Erstellung von fetten API-Bindungen in anderen Sprachen erleichtern, könnte den Prozess rationalisieren und beschleunigen.

Berücksichtigung von Plattformunterschieden: Bei der Übertragung auf andere Plattformen müssen möglicherweise spezifische Anpassungen vorgenommen werden, um die Interoperabilität und Leistung zu gewährleisten.

Durch sorgfältige Planung, Anpassung und Implementierung können die Konzepte der fetten API-Bindungen erfolgreich auf andere Sprachen und Plattformen außerhalb von JavaScript und Node.js übertragen werden.