WebAssembly-Modul in WAT zur Berechnung von Mittelwert, Median und Varianz für numerische Datensätze mit Speicherverwaltung und Bubble-Sort.
(module
;; Definition des exportierten linearen Speichers, 1 Seite = 64KiB
(memory (export "memory") 1)
;; Heap-Zeiger für einfache Zuweisungen
(global $heap_ptr (mut i32) (i32.const 0))
;; Funktion alloc: weist n Bytes zu und gibt Zeiger zurück
(func (export "alloc") (param $size i32) (result i32)
(local $ptr i32)
global.get $heap_ptr
local.tee $ptr
local.get $size
i32.add
global.set $heap_ptr
local.get $ptr
)
;; Funktion dealloc: Dummy (macht nichts, einfache manuelle Verwaltung)
(func (export "dealloc") (param $ptr i32) (param $size i32)
;; Nicht implementiert aus Einfachheitsgründen
nop
)
;; Funktion bubble_sort zum Sortieren eines i32-Arrays im Speicher
(func $bubble_sort (param $ptr i32) (param $len i32)
(local $i i32)
(local $j i32)
(local $tmp i32)
(local $val1 i32)
(local $val2 i32)
(local $offset1 i32)
(local $offset2 i32)
(local.set $i (i32.const 0))
(block $outer
(loop $loop_i
(local.set $j (i32.const 0))
(block $inner
(loop $loop_j
;; wenn j+1 >= len abbrechen
local.get $j
local.get $len
i32.const 1
i32.sub
i32.ge_u
br_if $inner
;; offset1 = ptr + j*4
local.get $ptr
local.get $j
i32.const 4
i32.mul
i32.add
local.set $offset1
;; offset2 = ptr + (j+1)*4
local.get $ptr
local.get $j
i32.const 1
i32.add
i32.const 4
i32.mul
i32.add
local.set $offset2
;; val1 = lade offset1
local.get $offset1
i32.load
local.set $val1
;; val2 = lade offset2
local.get $offset2
i32.load
local.set $val2
;; wenn val1 > val2 tauschen
local.get $val1
local.get $val2
i32.gt_s
if
;; speichere val2 an offset1
local.get $offset1
local.get $val2
i32.store
;; speichere val1 an offset2
local.get $offset2
local.get $val1
i32.store
end
;; j++
local.get $j
i32.const 1
i32.add
local.set $j
br $loop_j
)
)
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
;; wenn i >= len abbrechen
local.get $i
local.get $len
i32.ge_u
br_if $outer
br $loop_i
)
)
)
;; Funktion compute_stats:
;; Eingabe: ptr Array i32, Länge Array i32
;; Ausgabe: ptr struct {f64 Mittelwert, f64 Median, f64 Varianz}
(func (export "compute_stats") (param $ptr i32) (param $len i32) (result i32)
(local $sum f64)
(local $mean f64)
(local $var_sum f64)
(local $variance f64)
(local $median f64)
(local $i i32)
(local $val f64)
(local $copy_ptr i32)
(local $result_ptr i32)
;; Speicher für Array-Kopie zuweisen (len * 4 Bytes)
local.get $len
i32.const 4
i32.mul
call $alloc
local.set $copy_ptr
;; Eingabearray nach copy_ptr kopieren
(local.set $i (i32.const 0))
(block $copy_loop
(loop $copy_loop_inner
local.get $i
local.get $len
i32.ge_u
br_if $copy_loop
;; Wert von ptr + i*4 laden
local.get $ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.load
;; In copy_ptr + i*4 speichern
local.get $copy_ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.store
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
br $copy_loop_inner
)
)
;; copy_ptr sortieren
local.get $copy_ptr
local.get $len
call $bubble_sort
;; Summe berechnen
(local.set $sum (f64.const 0))
(local.set $i (i32.const 0))
(block $sum_loop
(loop $sum_loop_inner
local.get $i
local.get $len
i32.ge_u
br_if $sum_loop
;; i32 Wert laden und in f64 konvertieren
local.get $ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.get $sum
f64.add
local.set $sum
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
br $sum_loop_inner
)
)
;; Mittelwert berechnen
local.get $sum
f64.convert_i32_s local.get $len
f64.div
local.set $mean
;; Median berechnen
local.get $len
i32.const 2
i32.rem_u
if
;; ungerade Länge: Median = mittlerer Wert
local.get $copy_ptr
local.get $len
i32.const 2
i32.div_u
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.set $median
else
;; gerade Länge: Median = Durchschnitt der zwei mittleren Werte
local.get $copy_ptr
local.get $len
i32.const 2
i32.div_u
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.get $copy_ptr
local.get $len
i32.const 2
i32.div_u
i32.const 1
i32.sub
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
f64.add
f64.const 2
f64.div
local.set $median
end
;; Varianz berechnen
(local.set $var_sum (f64.const 0))
(local.set $i (i32.const 0))
(block $var_loop
(loop $var_loop_inner
local.get $i
local.get $len
i32.ge_u
br_if $var_loop
;; val = array[i]
local.get $ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.set $val
;; var_sum += (val - mean)^2
local.get $val
local.get $mean
f64.sub
local.tee $val
f64.mul
local.get $var_sum
f64.add
local.set $var_sum
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
br $var_loop_inner
)
)
;; varianz = var_sum / len
local.get $var_sum
f64.convert_i32_s local.get $len
f64.div
local.set $variance
;; Speicher für Ausgabestruktur zuweisen (3 * 8 Bytes = 24)
i32.const 24
call $alloc
local.set $result_ptr
;; Mittelwert schreiben
local.get $result_ptr
local.get $mean
f64.store
;; Median schreiben
local.get $result_ptr
i32.const 8
i32.add
local.get $median
f64.store
;; Varianz schreiben
local.get $result_ptr
i32.const 16
i32.add
local.get $variance
f64.store
;; Speicher der Array-Kopie freigeben
local.get $copy_ptr
local.get $len
i32.const 4
i32.mul
call $dealloc
;; Zeiger auf Ergebnisstruktur zurückgeben
local.get $result_ptr
)
)html
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<title>Beispiel: Berechnung beschreibender Statistiken mit WebAssembly</title>
</head>
<body>
<h1>Berechnung beschreibender Statistiken mit WebAssembly</h1>
<pre id="output"></pre>
<script>
// Originaler WebAssembly-Code als Text
const wasmCode = `(module
;; Definition des exportierten linearen Speichers, 1 Seite = 64KiB
(memory (export "memory") 1)
;; Heap-Zeiger für einfache Zuweisungen
(global $heap_ptr (mut i32) (i32.const 0))
;; Funktion alloc: weist n Bytes zu und gibt Zeiger zurück
(func (export "alloc") (param $size i32) (result i32)
(local $ptr i32)
global.get $heap_ptr
local.tee $ptr
local.get $size
i32.add
global.set $heap_ptr
local.get $ptr
)
;; Funktion dealloc: Dummy (macht nichts, einfache manuelle Verwaltung)
(func (export "dealloc") (param $ptr i32) (param $size i32)
;; Nicht implementiert aus Einfachheitsgründen
nop
)
;; Funktion bubble_sort zum Sortieren eines i32-Arrays im Speicher
(func $bubble_sort (param $ptr i32) (param $len i32)
(local $i i32)
(local $j i32)
(local $tmp i32)
(local $val1 i32)
(local $val2 i32)
(local $offset1 i32)
(local $offset2 i32)
(local.set $i (i32.const 0))
(block $outer
(loop $loop_i
(local.set $j (i32.const 0))
(block $inner
(loop $loop_j
;; wenn j+1 >= len abbrechen
local.get $j
local.get $len
i32.const 1
i32.sub
i32.ge_u
br_if $inner
;; offset1 = ptr + j*4
local.get $ptr
local.get $j
i32.const 4
i32.mul
i32.add
local.set $offset1
;; offset2 = ptr + (j+1)*4
local.get $ptr
local.get $j
i32.const 1
i32.add
i32.const 4
i32.mul
i32.add
local.set $offset2
;; val1 = lade offset1
local.get $offset1
i32.load
local.set $val1
;; val2 = lade offset2
local.get $offset2
i32.load
local.set $val2
;; wenn val1 > val2 tauschen
local.get $val1
local.get $val2
i32.gt_s
if
;; speichere val2 an offset1
local.get $offset1
local.get $val2
i32.store
;; speichere val1 an offset2
local.get $offset2
local.get $val1
i32.store
end
;; j++
local.get $j
i32.const 1
i32.add
local.set $j
br $loop_j
)
)
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
;; wenn i >= len abbrechen
local.get $i
local.get $len
i32.ge_u
br_if $outer
br $loop_i
)
)
)
;; Funktion compute_stats:
;; Eingabe: ptr Array i32, Länge Array i32
;; Ausgabe: ptr struct {f64 Mittelwert, f64 Median, f64 Varianz}
(func (export "compute_stats") (param $ptr i32) (param $len i32) (result i32)
(local $sum f64)
(local $mean f64)
(local $var_sum f64)
(local $variance f64)
(local $median f64)
(local $i i32)
(local $val f64)
(local $copy_ptr i32)
(local $result_ptr i32)
;; Speicher für Array-Kopie zuweisen (len * 4 Bytes)
local.get $len
i32.const 4
i32.mul
call $alloc
local.set $copy_ptr
;; Eingabearray nach copy_ptr kopieren
(local.set $i (i32.const 0))
(block $copy_loop
(loop $copy_loop_inner
local.get $i
local.get $len
i32.ge_u
br_if $copy_loop
;; Wert von ptr + i*4 laden
local.get $ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.load
;; In copy_ptr + i*4 speichern
local.get $copy_ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.store
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
br $copy_loop_inner
)
)
;; copy_ptr sortieren
local.get $copy_ptr
local.get $len
call $bubble_sort
;; Summe berechnen
(local.set $sum (f64.const 0))
(local.set $i (i32.const 0))
(block $sum_loop
(loop $sum_loop_inner
local.get $i
local.get $len
i32.ge_u
br_if $sum_loop
;; i32 Wert laden und in f64 konvertieren
local.get $ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.get $sum
f64.add
local.set $sum
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
br $sum_loop_inner
)
)
;; Mittelwert berechnen
local.get $sum
f64.convert_i32_s local.get $len
f64.div
local.set $mean
;; Median berechnen
local.get $len
i32.const 2
i32.rem_u
if
;; ungerade Länge: Median = mittlerer Wert
local.get $copy_ptr
local.get $len
i32.const 2
i32.div_u
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.set $median
else
;; gerade Länge: Median = Durchschnitt der zwei mittleren Werte
local.get $copy_ptr
local.get $len
i32.const 2
i32.div_u
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.get $copy_ptr
local.get $len
i32.const 2
i32.div_u
i32.const 1
i32.sub
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
f64.add
f64.const 2
f64.div
local.set $median
end
;; Varianz berechnen
(local.set $var_sum (f64.const 0))
(local.set $i (i32.const 0))
(block $var_loop
(loop $var_loop_inner
local.get $i
local.get $len
i32.ge_u
br_if $var_loop
;; val = array[i]
local.get $ptr
local.get $i
i32.const 4
i32.mul
i32.add
i32.load
f64.convert_i32_s
local.set $val
;; var_sum += (val - mean)^2
local.get $val
local.get $mean
f64.sub
local.tee $val
f64.mul
local.get $var_sum
f64.add
local.set $var_sum
;; i++
local.get $i
i32.const 1
i32.add
local.set $i
br $var_loop_inner
)
)
;; varianz = var_sum / len
local.get $var_sum
f64.convert_i32_s local.get $len
f64.div
local.set $variance
;; Speicher für Ausgabestruktur zuweisen (3 * 8 Bytes = 24)
i32.const 24
call $alloc
local.set $result_ptr
;; Mittelwert schreiben
local.get $result_ptr
local.get $mean
f64.store
;; Median schreiben
local.get $result_ptr
i32.const 8
i32.add
local.get $median
f64.store
;; Varianz schreiben
local.get $result_ptr
i32.const 16
i32.add
local.get $variance
f64.store
;; Speicher der Array-Kopie freigeben
local.get $copy_ptr
local.get $len
i32.const 4
i32.mul
call $dealloc
;; Zeiger auf Ergebnisstruktur zurückgeben
local.get $result_ptr
)
)`;
// Hilfsfunktion zum Laden von 64-bit float aus WebAssembly Speicher
function getFloat64FromMemory(memory, ptr) {
const bytes = new Uint8Array(memory.buffer, ptr, 8);
const view = new DataView(bytes.buffer);
return view.getFloat64(0, true); // little endian
}
(async () => {
// Kompiliere und instanziiere das WebAssembly Modul
const wasmModule = await WebAssembly.compile(new TextEncoder().encode(wasmCode));
const instance = await WebAssembly.instantiate(wasmModule);
const { memory, alloc, dealloc, compute_stats } = instance.exports;
// Beispiel-Datensatz
const zahlen = [10, 2, 38, 23, 38, 23, 21];
const len = zahlen.length;
// Speicher für das Array im wasm-Speicher reservieren
const bytesNeeded = len * 4;
const ptr = alloc(bytesNeeded);
// Array in wasm-Speicher schreiben
const wasmMemory = new Uint32Array(memory.buffer, ptr, len);
for (let i = 0; i < len; i++) {
wasmMemory[i] = zahlen[i];
}
// compute_stats aufrufen
const resultPtr = compute_stats(ptr, len);
// Ergebnis auslesen (Mittelwert, Median, Varianz)
const mean = getFloat64FromMemory(memory, resultPtr);
const median = getFloat64FromMemory(memory, resultPtr + 8);
const variance = getFloat64FromMemory(memory, resultPtr + 16);
// Speicher freigeben
dealloc(ptr, bytesNeeded);
dealloc(resultPtr, 24);
// Ausgabe
document.getElementById('output').textContent =
`Eingabedaten: ${zahlen.join(', ')}\n` +
`Mittelwert: ${mean.toFixed(2)}\n` +
`Median: ${median.toFixed(2)}\n` +
`Varianz: ${variance.toFixed(2)}`;
})();
</script>
</body>
</html>WebAssembly-Modul geschrieben in WAT (WebAssembly Text Format).
Exportierte Funktionen: alloc (zum Zuweisen von Speicher), dealloc (zum Freigeben von Speicher), compute_stats (berechnet Mittelwert, Median, Varianz).
Exportierter linearer Speicher für den Datenaustausch mit der Host-Umgebung.
Datenstruktur im Speicher: Eingabearray von 32-Bit-Ganzzahlen, Ausgabestruktur mit 3 float64 (Mittelwert, Median, Varianz).
Software-Konfiguration: Kompilieren mit wat2wasm (https://github.com/WebAssembly/wabt) zum Erzeugen des binären wasm-Moduls.
Typische Integration: Laden des wasm-Moduls in JavaScript, Zuweisung des Eingabepuffers, Schreiben der Daten, Aufruf von compute_stats, Lesen der Ergebnisse.
Software-Abhängigkeiten: keine externen Bibliotheken, nur Standard-WebAssembly-Laufzeit.
Arduino: nicht anwendbar (rein softwarebasiertes WebAssembly-Beispiel).