PricingLoginStart free
WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi · Pelajaran

Model & Pengurusan Memori WASM

Fahami model memori linear WebAssembly serta cara memori diperuntukkan, dicapai dan diurus dalam modul WASM.

Pelajaran 2 daripada 410 langkah

Model & Pengurusan Memori WASM ialah pelajaran WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi merangkumi sejumlah 4 pelajaran.

Memori Linear WASM: Asas

WebAssembly menggunakan model memori linear. Anggaplah ia sebagai satu tatasusunan besar bait yang bersebelahan, serupa dengan cara program tradisional mengurus memori.

  • Memori ini berasingan daripada memori JavaScript.
  • Modul WASM mengaksesnya sebagai ruang alamat rata yang bermula daripada alamat 0.
  • Semua data (integer, nombor titik apungan, rentetan, tatasusunan) berada dalam satu blok memori ini.

Objek `WebAssembly.Memory`

Dalam JavaScript, memori WASM diwakili oleh objek WebAssembly.Memory. Objek ini menyimpan penimbal memori sebenar.

Anda boleh menciptanya:

  • Semasa membuat tika modul WASM, modul itu boleh mengisytiharkan dan mencipta memorinya sendiri.
  • Anda juga boleh menghantar tika WebAssembly.Memory sedia ada daripada JavaScript kepada modul tersebut.
const memory = new WebAssembly.Memory({
  initial: 1, // Start with 1 page (64KB)
  maximum: 10 // Max allowed 10 pages
});

// This 'memory' object is then passed to the
// WASM module during instantiation.

Halaman Memori: Unit Saiz

Memori WASM disusun dalam unit bersaiz tetap yang dipanggil halaman. Setiap halaman berukuran tepat 64 KiB (65,536 bait).

  • Sifat initial dan maximum bagi WebAssembly.Memory sentiasa ditakrifkan berdasarkan halaman.
  • Modul WASM mungkin bermula dengan hanya 1 halaman dan mengembangkan memorinya mengikut keperluan demi kecekapan.
  • Sistem berasaskan halaman ini membolehkan pengurusan dan perlindungan memori yang cekap.

Paparan JavaScript ke dalam Memori

JavaScript tidak boleh mengakses memori linear WASM secara langsung menggunakan penuding mentah. Sebaliknya, JavaScript mendapatkan paparan ArrayBuffer bagi memori tersebut.

Anda kemudiannya menggunakan TypedArrays (seperti Uint8Array, Int32Array, Float64Array) atau DataView untuk membaca dan menulis jenis data tertentu pada ofset tertentu dalam ArrayBuffer tersebut.

const memoryBuffer = instance.exports.memory.buffer;
const uint8Array = new Uint8Array(memoryBuffer); // Byte-level view
const int32Array = new Int32Array(memoryBuffer); // 4-byte integer view

Memperuntukkan Memori dalam C/WASM

Apabila anda menyusun C/C++ kepada WASM, fungsi seperti malloc memperuntukkan memori daripada memori linear WASM. Contoh ini menunjukkan fungsi C yang memperuntukkan ruang untuk tatasusunan integer.

Fungsi ini mengembalikan ofset memori (iaitu integer), bukannya penuding langsung, yang kemudiannya digunakan oleh JavaScript.

#include <stdlib.h>
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#else
#define EMSCRIPTEN_KEEPALIVE
#endif

EMSCRIPTEN_KEEPALIVE
int* allocate_int_array(int size) {
  int* arr = (int*) malloc(size * sizeof(int));
  if (arr) {
    for (int i = 0; i < size; ++i) {
      arr[i] = i * 10; // Initialize with some data
    }
  }
  return arr; // Returns memory offset
}

int main() {
  // Main function is often a placeholder for WASM modules
  return 0;
}

Mengakses Memori yang Diperuntukkan oleh C daripada JS

Selepas WASM memperuntukkan memori (contohnya menggunakan allocate_int_array), JavaScript boleh mengaksesnya menggunakan ofset yang dikembalikan dan TypedArray.

Ofset tersebut memberitahu JS dengan tepat tempat data yang diperuntukkan bermula dalam ArrayBuffer asas, lalu membolehkan operasi membaca/menulis yang tepat.

// Assuming 'instance' is your WASM module instance
const offset = instance.exports.allocate_int_array(5);
const memoryBuffer = instance.exports.memory.buffer;

// Create an Int32Array view starting at the offset
const intArray = new Int32Array(memoryBuffer, offset, 5);

console.log(intArray[0]); // Expected: 0
console.log(intArray[1]); // Expected: 10
// ... and so on

Menyahperuntukkan Memori dengan `free`

Sama seperti dalam C, anda perlu menyahperuntukkan memori yang telah diperuntukkan menggunakan malloc untuk mengelakkan kebocoran memori. Fungsi free dalam WASM berfungsi dengan cara yang sama, iaitu melepaskan memori kembali kepada masa jalan WASM.

Fungsi C ini membebaskan blok memori yang telah diperuntukkan sebelum ini menggunakan ofsetnya.

#include <stdlib.h>
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#else
#define EMSCRIPTEN_KEEPALIVE
#endif

EMSCRIPTEN_KEEPALIVE
void free_wasm_memory(int* ptr) {
  if (ptr) {
    free(ptr); // Release the memory block
  }
}

int main() {
  return 0;
}

Membesarkan Memori Secara Dinamik

Memori WASM bukanlah tetap; saiznya boleh dibesarkan! Kaedah memory.grow(numPages) yang tersedia pada objek WebAssembly.Memory membolehkan anda meningkatkan saiz memori sebanyak bilangan halaman yang ditentukan.

  • Kaedah ini mengembalikan bilangan halaman sebelumnya.
  • Jika grow gagal (contohnya melebihi maximum), kaedah ini mengembalikan -1.
  • Penting: Paparan TypedArray yang sedia ada menjadi tidak sah selepas operasi pembesaran; anda mesti mencipta paparan baharu daripada memory.buffer yang dikemas kini.
const currentPages = instance.exports.memory.grow(1); // Add 1 page
console.log(`Memory grew from ${currentPages} pages.`);

// After growing, always recreate TypedArray views!
const newMemoryBuffer = instance.exports.memory.buffer;
const newUint8Array = new Uint8Array(newMemoryBuffer);

Semakan Pengurusan Memori

Antara pernyataan berikut, yang manakah TRUE tentang model memori linear WebAssembly?

Jawab dalam pelajaran interaktif

Ulang Kaji: Pengurusan Memori WASM

Kita telah meneroka model memori linear WebAssembly, iaitu konsep asas untuk aplikasi berprestasi tinggi.

  • Memori WASM ialah tatasusunan bait bersebelahan yang berasingan daripada memori JS.
  • Memori ini diuruskan oleh objek WebAssembly.Memory dan disusun dalam halaman berukuran 64 KiB.
  • JavaScript berinteraksi dengan memori ini menggunakan ArrayBuffer dan TypedArrays untuk membaca dan menulis data.
  • Fungsi C seperti malloc dan free beroperasi dalam ruang memori WASM ini, dengan `malloc` mengembalikan ofset.
  • Memori boleh ditambah secara dinamik menggunakan memory.grow(), tetapi paparan JS perlu dicipta semula.

Memahami konsep ini penting untuk pertukaran data dan pengendalian memori yang cekap dalam aplikasi WASM.

Percuma untuk bermula

Pelajari WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
12
Pelajaran
48
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Model & Pengurusan Memori WASM” percuma?

Ya — teks penuh “Model & Pengurusan Memori WASM” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi, tingkat taraf kepada CoddyKit PRO. Kursus WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Model & Pengurusan Memori WASM”?

Fahami model memori linear WebAssembly serta cara memori diperuntukkan, dicapai dan diurus dalam modul WASM. Anda berlatih WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi?

Tiada pengalaman terdahulu diperlukan. Pembelajaran WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Model & Pengurusan Memori WASM” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi ini?

Ya. Setiap pelajaran WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Menghantar Struktur Data Kompleks
  2. Model & Pengurusan Memori WASM
  3. Memori Dikongsi & Atomik
  4. Membesarkan dan Mengurus Memori Linear
← Kembali ke WebAssembly (WASM) untuk Aplikasi Berprestasi Tinggi