mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-27 01:03:19 +03:00
226 lines
9.7 KiB
Markdown
226 lines
9.7 KiB
Markdown
---
|
||
language: WebAssembly
|
||
lang: uk-ua
|
||
filename: learnwasm-ua.wast
|
||
contributors:
|
||
- ["Dean Shaff", "http://dean-shaff.github.io"]
|
||
translators:
|
||
- ["Oleh Hromiak", "https://github.com/ogroleg"]
|
||
---
|
||
|
||
```
|
||
;; learnwasm-ua.wast
|
||
|
||
(module
|
||
;; У WebAssembly весь код знаходиться в модулях. Будь-яка операція
|
||
;; може бути записана за допомогою s-виразу. Також існує синтаксис "стек машини",
|
||
;; втім, він не сумісний з проміжним бінарним представленням коду.
|
||
|
||
;; Формат бінарного проміжного представлення майже повністю сумісний
|
||
;; з текстовим форматом WebAssembly.
|
||
;; Деякі відмінності:
|
||
;; local_set -> local.set
|
||
;; local_get -> local.get
|
||
|
||
;; Код розміщується у функціях
|
||
|
||
;; Типи даних
|
||
(func $data_types
|
||
;; WebAssembly має чотири типи даних:
|
||
;; i32 - ціле число, 32 біти
|
||
;; i64 - ціле число, 64 біти (не підтримується у JavaScript)
|
||
;; f32 - число з плаваючою комою, 32 біти
|
||
;; f64 - число з плаваючою комою, 64 біти
|
||
|
||
;; Створити локальну змінну можна за допомогою ключового слова "local".
|
||
;; Змінні потрібно оголошувати на початку функції.
|
||
|
||
(local $int_32 i32)
|
||
(local $int_64 i64)
|
||
(local $float_32 f32)
|
||
(local $float_64 f64)
|
||
|
||
;; Змінні, оголошені вище, ще не ініціалізовані, себто, не мають значення.
|
||
;; Давайте присвоїмо їм значення за допомогою <тип даних>.const:
|
||
|
||
(local.set $int_32 (i32.const 16))
|
||
(local.set $int_32 (i64.const 128))
|
||
(local.set $float_32 (f32.const 3.14))
|
||
(local.set $float_64 (f64.const 1.28))
|
||
)
|
||
|
||
;; Базові операції
|
||
(func $basic_operations
|
||
|
||
;; Нагадаємо, у WebAssembly будь-що є s-виразом, включно
|
||
;; з математичними виразами або зчитуванням значень змінних
|
||
|
||
(local $add_result i32)
|
||
(local $mult_result f64)
|
||
|
||
(local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
|
||
;; тепер add_result дорівнює 6!
|
||
|
||
;; Для кожної операції потрібно використовувати правильний тип:
|
||
;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; Ніт! mult_result має тип f64!
|
||
(local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; Ніт! mult_result має тип f64!
|
||
|
||
;; У WebAssembly є вбудовані функції накшталт математики та побітових операцій.
|
||
;; Варто зазначити, що тут відсутні вбудовані тригонометричні функції.
|
||
;; Тож нам потрібно:
|
||
;; - написати їх самостійно (не найкраща ідея)
|
||
;; - звідкись їх імпортувати (як саме - побачимо згодом)
|
||
)
|
||
|
||
;; Функції
|
||
;; Параметри вказуються ключовим словом `param`, значення, що повертається - `result`
|
||
;; Поточне значення стеку і є значенням функції, що повертається
|
||
|
||
;; Ми можемо викликати інші функції за допомогою `call`
|
||
|
||
(func $get_16 (result i32)
|
||
(i32.const 16)
|
||
)
|
||
|
||
(func $add (param $param0 i32) (param $param1 i32) (result i32)
|
||
(i32.add
|
||
(local.get $param0)
|
||
(local.get $param1)
|
||
)
|
||
)
|
||
|
||
(func $double_16 (result i32)
|
||
(i32.mul
|
||
(i32.const 2)
|
||
(call $get_16))
|
||
)
|
||
|
||
;; Досі ми не могли що-небудь вивести на консоль і не мали доступу
|
||
;; до високорівневої математики (степеневі функції, обрахунок експоненти або тригонометрія).
|
||
;; Більше того, ми навіть не могли викликати WASM функції у Javascript!
|
||
;; Виклик цих функцій у WebAssembly залежить від того,
|
||
;; де ми знаходимось - чи це Node.js, чи середовище браузера.
|
||
|
||
;; Якщо ми у Node.js, то потрібно виконати два кроки. По-перше, ми маємо сконвертувати
|
||
;; текстове представлення WASM у справжній код webassembly.
|
||
;; Наприклад, ось так (Binaryen):
|
||
|
||
;; wasm-as learn-wasm.wast -o learn-wasm.wasm
|
||
|
||
;; Давай також застосуємо оптимізації:
|
||
|
||
;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
|
||
|
||
;; Тепер наш скомпільований WebAssembly можна завантажити у Node.js:
|
||
;; const fs = require('fs')
|
||
;; const instantiate = async function (inFilePath, _importObject) {
|
||
;; var importObject = {
|
||
;; console: {
|
||
;; log: (x) => console.log(x),
|
||
;; },
|
||
;; math: {
|
||
;; cos: (x) => Math.cos(x),
|
||
;; }
|
||
;; }
|
||
;; importObject = Object.assign(importObject, _importObject)
|
||
;;
|
||
;; var buffer = fs.readFileSync(inFilePath)
|
||
;; var module = await WebAssembly.compile(buffer)
|
||
;; var instance = await WebAssembly.instantiate(module, importObject)
|
||
;; return instance.exports
|
||
;; }
|
||
;;
|
||
;; const main = function () {
|
||
;; var wasmExports = await instantiate('learn-wasm.wasm')
|
||
;; wasmExports.print_args(1, 0)
|
||
;; }
|
||
|
||
;; Цей код зчитує функції з importObject
|
||
;; (вказано у асинхронній JavaScript функції instantiate), а потім експортує функцію
|
||
;; "print_args", яку ми викликаємо у Node.js
|
||
|
||
(import "console" "log" (func $print_i32 (param i32)))
|
||
(import "math" "cos" (func $cos (param f64) (result f64)))
|
||
|
||
(func $print_args (param $arg0 i32) (param $arg1 i32)
|
||
(call $print_i32 (local.get $arg0))
|
||
(call $print_i32 (local.get $arg1))
|
||
)
|
||
(export "print_args" (func $print_args))
|
||
|
||
;; Завантаження даних з пам'яті WebAssembly.
|
||
;; Наприклад, ми хочемо порахувати cos для елементів Javascript масиву.
|
||
;; Нам потрібно отримати доступ до масиву і можливість ітерувати по ньому.
|
||
;; У прикладі нижче ми змінимо існуючий масив.
|
||
;; f64.load і f64.store приймають адресу числа у пам'яті *у байтах*.
|
||
;; Для того, щоб отримати доступ до 3-го елементу масиву, ми маємо передати щось
|
||
;; накшталт (i32.mul (i32.const 8) (i32.const 2)) у функцію f64.store.
|
||
|
||
;; У JavaScript ми викличемо `apply_cos64` таким чином
|
||
;; (використаємо функцію instantiate з попереднього прикладу):
|
||
;;
|
||
;; const main = function () {
|
||
;; var wasm = await instantiate('learn-wasm.wasm')
|
||
;; var n = 100
|
||
;; const memory = new Float64Array(wasm.memory.buffer, 0, n)
|
||
;; for (var i=0; i<n; i++) {
|
||
;; memory[i] = i;
|
||
;; }
|
||
;; wasm.apply_cos64(n)
|
||
;; }
|
||
;;
|
||
;; Ця функція не буде працювати, якщо ми виділимо пам'ять для (створимо) Float32Array у JavaScript.
|
||
|
||
(memory (export "memory") 100)
|
||
|
||
(func $apply_cos64 (param $array_length i32)
|
||
;; визначаємо змінну циклу або лічильник
|
||
(local $idx i32)
|
||
;; визначаємо змінну для доступу до пам'яті
|
||
(local $idx_bytes i32)
|
||
;; константа - кількість байтів у числі типу f64.
|
||
(local $bytes_per_double i32)
|
||
|
||
;; визначаємо змінну, яка зберігатиме значення з пам'яті
|
||
(local $temp_f64 f64)
|
||
|
||
(local.set $idx (i32.const 0))
|
||
(local.set $idx_bytes (i32.const 0)) ;; не обов'язково
|
||
(local.set $bytes_per_double (i32.const 8))
|
||
|
||
(block
|
||
(loop
|
||
;; записуємо у idx_bytes необхідне зміщення в пам'яті - для поточного числа.
|
||
(local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
|
||
|
||
;; отримуємо число з пам'яті (за зміщенням):
|
||
(local.set $temp_f64 (f64.load (local.get $idx_bytes)))
|
||
|
||
;; рахуємо cos:
|
||
(local.set $temp_64 (call $cos (local.get $temp_64)))
|
||
|
||
;; тепер зберігаємо результат обчислень у пам'ять:
|
||
(f64.store
|
||
(local.get $idx_bytes)
|
||
(local.get $temp_64))
|
||
|
||
;; або робимо все за один крок (альтернативний код)
|
||
(f64.store
|
||
(local.get $idx_bytes)
|
||
(call $cos
|
||
(f64.load
|
||
(local.get $idx_bytes))))
|
||
|
||
;; збільшуємо лічильник на одиницю (інкремент)
|
||
(local.set $idx (i32.add (local.get $idx) (i32.const 1)))
|
||
|
||
;; якщо лічильник дорівнює довжині масиву, то завершуємо цикл
|
||
(br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
|
||
(br 0)
|
||
)
|
||
)
|
||
)
|
||
(export "apply_cos64" (func $apply_cos64))
|
||
)
|
||
```
|