WebAssembly und Swift: Fortgeschrittene Integration auf iOS/macOS

Einführung in WebAssembly für Swift-Entwickler

WebAssembly (Wasm) ist ein Low-Level-Binärbefehlssatz, der in einer isolierten virtuellen Maschine läuft. Für einen Swift-Entwickler auf iOS/macOS eröffnet die Wasm-Integration neue Horizonte: Code-Übertragung von anderen Sprachen, Sandboxing für Drittanbieter-Bibliotheken und Ausführung von Hochleistungsberechnungen ohne nativen Code. In diesem Artikel betrachten wir fortgeschrittene Techniken für die Arbeit mit WebAssembly in Swift: von der Kompilierung bis zur direkten Speicherarbeit und Funktionsaufrufen.

Im Gegensatz zu grundlegenden Tutorials konzentrieren wir uns auf reale Aufgaben: Übergabe komplexer Datentypen, manuelle Speicherverwaltung und Leistungsoptimierung. Es wird vorausgesetzt, dass Sie bereits mit den Grundlagen von Swift und dem grundlegenden Konzept von WebAssembly vertraut sind.

Kompilierung von Code in WebAssembly für Swift

Werkzeuge und Einrichtung

Für die Kompilierung von Drittanbieter-Code (C/C++/Rust) in Wasm verwenden Sie Emscripten oder wasm-pack (für Rust). Für reines Swift gibt es das Projekt SwiftWasm, das jedoch eingeschränkt ist. Meistens werden Sie vorgefertigte Module integrieren.

Beispiel für die Kompilierung einer einfachen C-Funktion in Wasm:

// math.cint add(int a, int b) {    return a + b;}

Befehl:

emcc math.c -o math.wasm -s WASM=1 -s EXPORTED_FUNCTIONS='["_add"]' -Os

Wichtige Flags: EXPORTED_FUNCTIONS — gibt an, welche Funktionen exportiert werden, -Os — Größenoptimierung. Die resultierende math.wasm ist bereit zum Laden in Swift.

Laden des Moduls in Swift

Auf iOS/macOS verwenden Sie für die Arbeit mit Wasm WasmKit oder WKWebView. Betrachten wir die fortgeschrittene Variante — WasmKit mit direkter Speicherverwaltung.

import WasmKit

guard let wasmData = try? Data(contentsOf: URL(fileURLWithPath: "math.wasm")) else {    fatalError("Wasm konnte nicht geladen werden")}

let module = try WasmModule(data: wasmData)let engine = WasmEngine()let instance = try engine.instantiate(module: module)

// Exportierte Funktion abrufenguard let addFunc = instance.export("add")?.function else {    fatalError("Funktion add nicht gefunden")}

Beachten Sie: WasmKit erfordert manuelle Verwaltung von Importen und Speicher. Dies bietet vollständige Kontrolle, erhöht aber die Komplexität.

Direkte Arbeit mit dem Speicher: Übergabe von Arrays und Zeichenketten

Linearer Speicher von Wasm

WebAssembly verwendet linearen Speicher (linear memory) — ein flaches Byte-Array. Für die Übergabe komplexer Strukturen (Arrays, Zeichenketten) müssen Sie Speicher innerhalb von Wasm zuweisen und Daten kopieren.

Betrachten wir ein Beispiel: Übergabe eines Integer-Arrays von Swift an eine Wasm-Funktion, die die Summe berechnet.

// sum_array.cint sum_array(int* arr, int len) {    int sum = 0;    for (int i = 0; i < len; i++) {        sum += arr[i];    }    return sum;}

Kompilieren mit Export von malloc und free:

emcc sum_array.c -o sum_array.wasm -s WASM=1 -s EXPORTED_FUNCTIONS='["_sum_array", "_malloc", "_free"]' -s ALLOW_MEMORY_GROWTH=1

In Swift Speicher zuweisen, Daten kopieren und die Funktion aufrufen:

let numbers = [10, 20, 30, 40, 50]let count = numbers.count

// Speicher für das Array zuweisen (4 Bytes pro int)guard let mallocFunc = instance.export("malloc")?.function else { return }let ptrResult = mallocFunc.call(Int32(count * MemoryLayout<Int32>.size))guard let ptr = ptrResult?.i32 else { return }

// Daten in den Wasm-Speicher kopierenlet memory = instance.memory!for i in 0..<count {    let offset = ptr + Int32(i * MemoryLayout<Int32>.size)    memory.store(offset: Int(offset), value: Int32(numbers[i]))}

// sum_array aufrufenguard let sumArrayFunc = instance.export("sum_array")?.function else { return }let result = sumArrayFun