बाइनरी के साथ Wasm को कंपाइल और ऑप्टिमाइज़ करना

Thomas Steiner

Binaryen एक कंपाइलर और टूलचेन है WebAssembly की इन्फ़्रास्ट्रक्चर लाइब्रेरी, जो C++ में लिखी गई है. इसका मकसद है कि इसे कंपाइल करना आसान, तेज़, और असरदार है. इस पोस्ट में, यह एक सिंथेटिक टॉय लैंग्वेज का उदाहरण है, जिसे ExampleScript है. लिखना सीखें Benaryen.js API का इस्तेमाल करके JavaScript में WebAssembly मॉड्यूल. आप यह कवर करेंगे मॉड्यूल बनाने, मॉड्यूल के साथ काम करने, और उसे एक्सपोर्ट करने के बारे में बुनियादी बातें मॉड्यूल से फ़ंक्शन के इस्तेमाल की जा सकती है. इससे आपको हर तरह की जानकारी मिलेगी WebAssembly में असल प्रोग्रामिंग भाषाओं को कंपाइल करने की तकनीक. इसके अलावा, आप इनके साथ Wasm मॉड्यूल को ऑप्टिमाइज़ करने के तरीके के बारे में जानेंगे. कमांड लाइन जोड़ें, जिसमें wasm-opt शामिल है.

बाइनरीयन के बारे में जानकारी

बाइनरीयन में C API हेडर में दिखेगा. साथ ही, इन्हें JavaScript से इस्तेमाल किया गया है. यह इनपुट, WebAssembly फ़ॉर्म, लेकिन यह कंट्रोल फ़्लो ग्राफ़ जो इसे पसंद करते हैं.

इंटरमीडिएट रिप्रज़ेंटेशन (आईआर) वह डेटा स्ट्रक्चर या कोड होता है जिसका इस्तेमाल किया जाता है यह एक कंपाइलर या वर्चुअल मशीन की मदद से होता है, जो सोर्स कोड को दिखाता है. बाइनरींस इंटरनल आईआर, कॉम्पैक्ट डेटा स्ट्रक्चर का इस्तेमाल करती है. इसे पूरी तरह से सभी उपलब्ध सीपीयू कोर का इस्तेमाल करके, कोड जनरेट करना और ऑप्टिमाइज़ करना. बाइनरी का आईआर WebAssembly का सबसेट होने की वजह से, WebAssembly में कंपाइल हो जाता है.

बाइनरीयन के ऑप्टिमाइज़र में ऐसे कई पास हैं जो कोड का साइज़ और स्पीड बढ़ा सकते हैं. ये ऑप्टिमाइज़ेशन का मकसद, बाइनरीयन को कंपाइलर के तौर पर इस्तेमाल करने के लिए मज़बूत बनाना है वह खुद बैकएंड में काम करता हो. इसमें WebAssembly के खास ऑप्टिमाइज़ेशन शामिल हैं (जिसमें अलग-अलग कामों के लिए इस्तेमाल किए जाने वाले कंपाइलर शायद ऐसा न करें), जिसे आप Wasm के तौर पर समझ सकते हैं छोटा करना.

बाइनरीन के उदाहरण के तौर पर AssemblyScript

बाइनरीयन का इस्तेमाल कई प्रोजेक्ट में किया जाता है. उदाहरण के लिए, AssemblyScript, जो बाइनरीन का इस्तेमाल इन कामों के लिए करती है टाइपस्क्रिप्ट जैसी भाषा से सीधे WebAssembly में कंपाइल करें. उदाहरण आज़माएं में मौजूद है.

AssemblyScript इनपुट:

export function add(a: i32, b: i32): i32 {
  return a + b;
}

मिलता-जुलता WebAssembly कोड, टेक्स्ट के तौर पर बाइनरीन से जनरेट किया गया है:

(module
 (type $0 (func (param i32 i32) (result i32)))
 (memory $0 0)
 (export "add" (func $module/add))
 (export "memory" (memory $0))
 (func $module/add (param $0 i32) (param $1 i32) (result i32)
  local.get $0
  local.get $1
  i32.add
 )
)

बाइनरी टूलचेन

बाइनरी टूलचेन दोनों JavaScript के लिए कई काम के टूल उपलब्ध कराता है कमांड लाइन इस्तेमाल करने वाले लोग. इन टूल का एक सबसेट यहां दिया गया है: फ़ॉलो किया जा रहा है; यह शामिल टूल की पूरी सूची प्रोजेक्ट की README फ़ाइल पर उपलब्ध है.

• binaryen.js: एक स्टैंडअलोन JavaScript लाइब्रेरी, जो बाइनरीयन तरीके दिखाती है इसके लिए Wasm मॉड्यूल बनाना और ऑप्टिमाइज़ करना. बिल्ड के लिए, npm पर binaryen.js देखें (या इसे सीधे यहां से डाउनलोड करें GitHub या unpkg).
• wasm-opt: यह कमांड लाइन टूल, WebAssembly को लोड करता है और बाइनरीन IR को चलाता है पास कर देता है.
• wasm-as और wasm-dis: जोड़ने और अलग करने वाले कमांड-लाइन टूल WebAssembly.
• wasm-ctor-eval: यह कमांड लाइन टूल, जो फ़ंक्शन (या फ़ंक्शन).
• wasm-metadce: कमांड लाइन टूल की मदद से, Wasm फ़ाइलों के हिस्सों को ज़रूरत के हिसाब से हटाया जा सकता है जो इस बात पर निर्भर करता है कि मॉड्यूल का इस्तेमाल कैसे किया जाता है.
• wasm-merge: यह कमांड लाइन टूल, जो कई Wasm फ़ाइलों को एक साथ मर्ज करता है फ़ाइल होगी, जिससे संबंधित इंपोर्ट को भी एक्सपोर्ट से कनेक्ट किया जा सकेगा. जैसे बंडलर का इस्तेमाल JavaScript के लिए, लेकिन Wasm के लिए करें.

WebAssembly में कंपाइल किया जा रहा है

एक भाषा को दूसरी भाषा में लिखने के लिए, आम तौर पर कई चरणों को पूरा करना होता है. सबसे ज़रूरी कीवर्ड नीचे दी गई सूची में मौजूद हैं:

• लेक्सिकल विश्लेषण: सोर्स कोड को टोकन में बांटें.
• सिंटैक्स विश्लेषण: एक ऐब्स्ट्रैक्ट सिंटैक्स ट्री बनाएं.
• अर्थ विश्लेषण: गड़बड़ियों की जांच करें और भाषा के नियम लागू करें.
• इंटरमीडिएट कोड जनरेशन: चीज़ों को ज़्यादा ऐब्स्ट्रैक्ट तरीके से दिखाना.
• कोड जनरेशन: जिस भाषा में अनुवाद करना है उसमें अनुवाद करें.
• टारगेट के हिसाब से कोड ऑप्टिमाइज़ेशन: टारगेट के लिए ऑप्टिमाइज़ करें.

यूनिक्स दुनिया में, कंपाइल करने के लिए अक्सर इस्तेमाल किए जाने वाले टूल lex और yacc:

• lex (लेक्सिकल एनालाइज़र जनरेटर): lex एक ऐसा टूल है जो लेक्सिकल जनरेट करता है ऐनालाइज़र, जिन्हें लेक्सर या स्कैनर भी कहा जाता है. इसके लिए सामान्य और संबंधित कार्रवाइयों को इनपुट के रूप में शामिल करता है और लेक्सिकल ऐनालाइज़र, जो इनपुट सोर्स कोड में पैटर्न की पहचान करता है.
• yacc (एक और कंपाइलर कंपाइलर): yacc एक ऐसा टूल है जो इस्तेमाल करें. यह प्रोग्रामिंग भाषा को इनपुट के रूप में इस्तेमाल करता है और पार्सर के लिए कोड जनरेट करता है. पार्सर आम तौर पर, ऐब्स्ट्रैक्ट सिंटैक्स ट्री (AST) जो सोर्स कोड की हैरारकी को दिखाती हैं.

काम का उदाहरण

इस पोस्ट में शामिल कॉन्टेंट को देखते हुए, पूरी प्रोग्रामिंग को कवर करना नामुमकिन है इसलिए, सरलता के लिए, सीमित और बेकार ExampleScript नाम की सिंथेटिक प्रोग्रामिंग भाषा सामान्य कार्रवाइयों के बारे में जानते हैं.

• एक add() फ़ंक्शन लिखने के लिए, आप किसी भी जोड़ का उदाहरण कोड अप करते हैं, जैसे कि 2 + 3.
• multiply() फ़ंक्शन लिखने के लिए, जैसे 6 * 12 लिखें.

पहले से दी गई चेतावनी के मुताबिक, यह बिलकुल बेकार है, लेकिन इसके लेक्सिकल के लिए काफ़ी आसान है ऐनालाइज़र को एक ही रेगुलर एक्सप्रेशन में बदलें: /\d+\s*[\+\-\*\/]\s*\d+\s*/.

इसके बाद, एक पार्सर होना चाहिए. दरअसल, इसका बहुत आसान वर्शन एक ऐब्स्ट्रैक्ट सिंटैक्स ट्री बनाने के लिए, रेगुलर एक्सप्रेशन का इस्तेमाल नाम वाले कैप्चरिंग ग्रुप: /(?<first_operand>\d+)\s*(?<operator>[\+\-\*\/])\s*(?<second_operand>\d+)/.

ExampleScript के हर लाइन में एक निर्देश दें, ताकि पार्सर कोड को प्रोसेस कर सके डेटा की लाइन के हिसाब से डेटा को अलग-अलग लाइन में बांटना चाहिए. यह पहला चेक करने के लिए काफ़ी है बुलेट सूची से पहले के तीन चरण, जैसे कि लेक्सिकल विश्लेषण, सिंटैक्स विश्लेषण और सिमेंटिक विश्लेषण शामिल हैं. इन चरणों का कोड नीचे दी गई सूची से हटाएं.

export default class Parser {
  parse(input) {
    input = input.split(/\n/);
    if (!input.every((line) => /\d+\s*[\+\-\*\/]\s*\d+\s*/gm.test(line))) {
      throw new Error('Parse error');
    }

    return input.map((line) => {
      const { groups } =
        /(?<first_operand>\d+)\s*(?<operator>[\+\-\*\/])\s*(?<second_operand>\d+)/gm.exec(
          line,
        );
      return {
        firstOperand: Number(groups.first_operand),
        operator: groups.operator,
        secondOperand: Number(groups.second_operand),
      };
    });
  }
}

इंटरमीडिएट कोड जनरेशन

अब ExampleScript प्रोग्राम को एक ऐब्स्ट्रैक्ट सिंटैक्स ट्री के तौर पर दिखाया जा सकता है (भले ही यह पूरी तरह से आसान हो), फिर अगला कदम है इंटरमीडिएट प्रतिनिधित्व. पहला कदम यह है कि बाइनरी में एक नया मॉड्यूल बनाएं:

const module = new binaryen.Module();

ऐब्स्ट्रैक्ट सिंटैक्स ट्री की हर लाइन में तीन firstOperand, operator, और secondOperand. चारों में से हर एक के लिए ExampleScript में ऑपरेटर, यानी +, -, *, /, एक नया मॉड्यूल में फ़ंक्शन जोड़ना ज़रूरी है बाइनरीयन की Module#addFunction() विधि से. इसके पैरामीटर Module#addFunction() तरीके इस तरह हैं:

• name: string, फ़ंक्शन का नाम दिखाता है.
• functionType: Signature, फ़ंक्शन के हस्ताक्षर के बारे में बताता है.
• varTypes: Type[], दिए गए क्रम में अन्य स्थानीय लोगों की जानकारी देता है.
• body: एक Expression, फ़ंक्शन का कॉन्टेंट.

आपके पास आराम करने और विश्लेषण करने के लिए बाइनरी डॉक्यूमेंटेशन से आपको स्पेस को नेविगेट करने में मदद मिल सकती है, लेकिन बाद में ExampleScript के + के लिए, ऑपरेटर, तो आप कई में से एक के रूप में Module#i32.add() तरीके पर पहुंच जाते हैं उपलब्ध है पूर्णांक वाली कार्रवाइयां. जोड़ने के लिए दो ऑपरेंड की ज़रूरत होती है, पहला और दूसरा संक्षेप. फ़ंक्शन है, तो कॉल करने योग्य होना चाहिए, तो उसे एक्सपोर्ट किया गया Module#addFunctionExport() के साथ.

module.addFunction(
  'add', // name: string
  binaryen.createType([binaryen.i32, binaryen.i32]), // params: Type
  binaryen.i32, // results: Type
  [binaryen.i32], // vars: Type[]
  //  body: ExpressionRef
  module.block(null, [
    module.local.set(
      2,
      module.i32.add(
        module.local.get(0, binaryen.i32),
        module.local.get(1, binaryen.i32),
      ),
    ),
    module.return(module.local.get(2, binaryen.i32)),
  ]),
);
module.addFunctionExport('add', 'add');

ऐब्स्ट्रैक्ट सिंटैक्स ट्री को प्रोसेस करने के बाद, मॉड्यूल में चार तरीके होते हैं, तीन, पूर्णांक के साथ काम करते हैं, जिसका नाम है add() Module#i32.add() के आधार पर, Module#i32.sub() पर आधारित subtract(), इस पर आधारित multiply() Module#i32.mul() और Module#f64.div() पर आधारित बाहरी divide() क्योंकि ExampleScript फ़्लोटिंग पॉइंट के नतीजों के साथ भी काम करता है.

for (const line of parsed) {
      const { firstOperand, operator, secondOperand } = line;

      if (operator === '+') {
        module.addFunction(
          'add', // name: string
          binaryen.createType([binaryen.i32, binaryen.i32]), // params: Type
          binaryen.i32, // results: Type
          [binaryen.i32], // vars: Type[]
          //  body: ExpressionRef
          module.block(null, [
            module.local.set(
              2,
              module.i32.add(
                module.local.get(0, binaryen.i32),
                module.local.get(1, binaryen.i32)
              )
            ),
            module.return(module.local.get(2, binaryen.i32)),
          ])
        );
        module.addFunctionExport('add', 'add');
      } else if (operator === '-') {
        module.subtractFunction(
          // Skipped for brevity.
        )
      } else if (operator === '*') {
          // Skipped for brevity.
      }
      // And so on for all other operators, namely `-`, `*`, and `/`.

अगर असल कोड बेस का इस्तेमाल किया जाता है, तो कभी-कभी ऐसा कोड काम नहीं करेगा जो कभी काम न करे कॉल किया जाता है. खराब कोड को आर्टिफ़िशियल तरीके से पेश करना (जिसे ऑप्टिमाइज़ किया जाएगा और को बाद के चरण में हटा दिया जाता है) के लिए, Wasm के साथ किया गया कंपाइलेशन काम करता है, लेकिन एक्सपोर्ट नहीं किया जा सकने वाला फ़ंक्शन जोड़ने से काम हो जाता है.

// This function is added, but not exported,
// so it's effectively dead code.
module.addFunction(
  'deadcode', // name: string
  binaryen.createType([binaryen.i32, binaryen.i32]), // params: Type
  binaryen.i32, // results: Type
  [binaryen.i32], // vars: Type[]
  //  body: ExpressionRef
  module.block(null, [
    module.local.set(
      2,
      module.i32.div_u(
        module.local.get(0, binaryen.i32),
        module.local.get(1, binaryen.i32),
      ),
    ),
    module.return(module.local.get(2, binaryen.i32)),
  ]),
);

कंपाइलर अब करीब-करीब तैयार है. यह ज़रूरी नहीं है, लेकिन ज़रूरी है अच्छा तरीका मॉड्यूल की पुष्टि करें Module#validate() तरीके का इस्तेमाल करके.

if (!module.validate()) {
  throw new Error('Validation error');
}

नतीजे के तौर पर मिला Wasm कोड पाना

यहां की यात्रा पर हूं इससे बनने वाले Wasm कोड को पाने के लिए, बाइनरीयन में दो तरीके मौजूद हैं टेक्स्ट के तौर पर दिखाना S-expression में .wat फ़ाइल के तौर पर आसानी से पढ़ सकते हैं और बाइनरी रिप्रज़ेंटेशन को .wasm फ़ाइल के तौर पर सेव करें, जो सीधे ब्राउज़र में चल सके. बाइनरी कोड ब्राउज़र में चल सकते हैं. यह काम कर रहा है, यह देखने के लिए, एक्सपोर्ट को लॉग करके मदद मिल सकती है.

const textData = module.emitText();
console.log(textData);

const wasmData = module.emitBinary();
const compiled = new WebAssembly.Module(wasmData);
const instance = new WebAssembly.Instance(compiled, {});
console.log('Wasm exports:\n', instance.exports);

एक ExampleScript प्रोग्राम के लिए, पूरे टेक्स्ट के तौर पर निरूपण कार्रवाइयों की जानकारी नीचे दी गई है. ध्यान दें कि खराब कोड अब भी वहां कैसे मौजूद है, लेकिन वह WebAssembly.Module.exports().

(module
 (type $0 (func (param i32 i32) (result i32)))
 (type $1 (func (param f64 f64) (result f64)))
 (export "add" (func $add))
 (export "subtract" (func $subtract))
 (export "multiply" (func $multiply))
 (export "divide" (func $divide))
 (func $add (param $0 i32) (param $1 i32) (result i32)
  (local $2 i32)
  (local.set $2
   (i32.add
    (local.get $0)
    (local.get $1)
   )
  )
  (return
   (local.get $2)
  )
 )
 (func $subtract (param $0 i32) (param $1 i32) (result i32)
  (local $2 i32)
  (local.set $2
   (i32.sub
    (local.get $0)
    (local.get $1)
   )
  )
  (return
   (local.get $2)
  )
 )
 (func $multiply (param $0 i32) (param $1 i32) (result i32)
  (local $2 i32)
  (local.set $2
   (i32.mul
    (local.get $0)
    (local.get $1)
   )
  )
  (return
   (local.get $2)
  )
 )
 (func $divide (param $0 f64) (param $1 f64) (result f64)
  (local $2 f64)
  (local.set $2
   (f64.div
    (local.get $0)
    (local.get $1)
   )
  )
  (return
   (local.get $2)
  )
 )
 (func $deadcode (param $0 i32) (param $1 i32) (result i32)
  (local $2 i32)
  (local.set $2
   (i32.div_u
    (local.get $0)
    (local.get $1)
   )
  )
  (return
   (local.get $2)
  )
 )
)

WebAssembly को ऑप्टिमाइज़ करना

Wasm कोड को ऑप्टिमाइज़ करने के दो तरीके हैं. एकbinaryen.js में भी और एक कमांड लाइन के लिए. पहला नियम, ऑप्टिमाइज़ेशन का स्टैंडर्ड सेट लागू होता है नियम डिफ़ॉल्ट रूप से सेट किए जा सकते हैं और ऑप्टिमाइज़ और छोटा होने का लेवल सेट किया जा सकता है, और डिफ़ॉल्ट रूप से, अन्य नियमों का इस्तेमाल नहीं करता. हालांकि, इसके बजाय इसे पूरी तरह से पसंद के मुताबिक बनाने की अनुमति देता है, इसका मतलब है कि काफ़ी प्रयोग करके, आप अपने विज्ञापनों के लिए सेटिंग, आपके कोड के आधार पर बेहतर नतीजे मिल सकते हैं.

binaryen.js के साथ ऑप्टिमाइज़ करना

बाइनरीन की मदद से Wasm मॉड्यूल को आसानी से ऑप्टिमाइज़ किया जा सकता है सीधेbinaryen.js के Module#optimize() तरीके को कॉल करें और विकल्प के तौर पर सेट कर रही हूँ ऑप्टिमाइज़ करें और छोटा करने का लेवल चुनें.

// Assume the `wast` variable contains a Wasm program.
const module = binaryen.parseText(wast);
binaryen.setOptimizeLevel(2);
binaryen.setShrinkLevel(1);
// This corresponds to the `-Os` setting.
module.optimize();

ऐसा करने से वह डेड कोड हटा दिया जाएगा जिसे पहले आर्टिफ़िशियल तरीके से पेश किया गया था. इसलिए, exampleScript खिलौने के Wasm वर्शन को टेक्स्ट के तौर पर दिखाने का उदाहरण नहीं लंबे समय तक शामिल रहता है. यह भी ध्यान दें कि local.set/get जोड़े को ऑप्टिमाइज़ेशन का तरीका SimplifyLocals (कई तरह के स्थानीय लोगों से जुड़े ऑप्टिमाइज़ेशन) और वैक्यूम (यह साफ़ तौर पर ग़ैर-ज़रूरी कोड को हटाता है) और return को RemoveUnusedBrs (उन जगहों के लिए ब्रेक हटाता है जिनकी ज़रूरत नहीं है).

 (module
 (type $0 (func (param i32 i32) (result i32)))
 (type $1 (func (param f64 f64) (result f64)))
 (export "add" (func $add))
 (export "subtract" (func $subtract))
 (export "multiply" (func $multiply))
 (export "divide" (func $divide))
 (func $add (; has Stack IR ;) (param $0 i32) (param $1 i32) (result i32)
  (i32.add
   (local.get $0)
   (local.get $1)
  )
 )
 (func $subtract (; has Stack IR ;) (param $0 i32) (param $1 i32) (result i32)
  (i32.sub
   (local.get $0)
   (local.get $1)
  )
 )
 (func $multiply (; has Stack IR ;) (param $0 i32) (param $1 i32) (result i32)
  (i32.mul
   (local.get $0)
   (local.get $1)
  )
 )
 (func $divide (; has Stack IR ;) (param $0 f64) (param $1 f64) (result f64)
  (f64.div
   (local.get $0)
   (local.get $1)
  )
 )
)

कई ऑप्टिमाइज़ेशन पास, और Module#optimize() खास तौर पर, 'ऑप्टिमाइज़ और कम करें' लेवल का इस्तेमाल करता है डिफ़ॉल्ट सेट. इसे पूरी तरह से पसंद के मुताबिक बनाने के लिए, आपको कमांड-लाइन टूल wasm-opt का इस्तेमाल करना होगा.

Wasm-ऑप्ट कमांड लाइन टूल की मदद से ऑप्टिमाइज़ किया जा रहा है

इस्तेमाल किए जाने वाले पास को पूरी तरह से पसंद के मुताबिक बनाने के लिए, बाइनरीन ने wasm-opt कमांड लाइन टूल. पाने के लिए ऑप्टिमाइज़ेशन के संभावित विकल्पों की पूरी सूची, टूल का सहायता मैसेज देखें. ऐसा हो सकता है कि wasm-opt टूल सबसे ज़्यादा लोकप्रिय हो इसका इस्तेमाल किया जाता है. साथ ही, इसका इस्तेमाल Wasm कोड को ऑप्टिमाइज़ करने के लिए, कई कंपाइलर टूलचेन में किया जाता है, इसमें एम्स्क्रिप्टन, जे2सीएल, कोटलिन/वासम, dart2wasm, vasm-pack वगैरह.

wasm-opt --help

यहां कुछ पास दिए गए हैं, ताकि आप उन्हें इस्तेमाल कर सकें. यह जानकारी यहां दी गई है इन्हें विशेषज्ञों की जानकारी के बिना समझा जा सकता है:

• CodeFolding: डुप्लीकेट कोड को मर्ज करके, इससे बचा जा सकता है (उदाहरण के लिए, अगर दो if ग्रुप में कुछ निर्देश होते हैं.
• DeadArgumentEli सुरक्षा: आर्ग्युमेंट हटाने के लिए, टाइम ऑप्टिमाइज़ेशन पास को लिंक करें फ़ंक्शन का इस्तेमाल करें, अगर इसे हमेशा समान कॉन्सटेंट के साथ कॉल किया जाता है.
• MinifyImportsAndExports: इन्हें कम से कम "a", "b" करता है.
• DeadCodeElimation: बंद कोड को हटाएं.

कई ऑप्टिमाइज़ेशन की कुकबुक के साथ कई सलाह के साथ उपलब्ध है, जिससे यह पता लगाया जा सकता है कि अलग-अलग फ़्लैग में से किसे अहम और सबसे पहले आज़माने लायक हैं. उदाहरण के लिए, कभी-कभी wasm-opt चलाने पर बार-बार, इनपुट को और छोटा कर देता है. ऐसे मामलों में, अगर आपके पास के साथ --converge फ़्लैग यह तब तक बार-बार आता रहता है, जब तक कोई और ऑप्टिमाइज़ेशन नहीं होता और एक तय पॉइंट पहुंच गया.

डेमो

इस पोस्ट में बताए गए कॉन्सेप्ट को इस्तेमाल करने के लिए, एम्बेड किए गए डेमो इसे ऐसा कोई भी ExampleScript इनपुट देगा, जिसके बारे में आप सोच सकते हैं. यह भी पक्का करें कि डेमो का सोर्स कोड देखें.

मीटिंग में सामने आए नतीजे

बाइनरी, WebAssembly में भाषाओं को कंपाइल करने और इससे मिलने वाले कोड को ऑप्टिमाइज़ करना. इसकी JavaScript लाइब्रेरी और कमांड-लाइन टूल सुविधा और टूल को ज़रूरत के हिसाब से और आसानी से इस्तेमाल किया जा सकता है. इस पोस्ट में, Google News पर Wasm का कंपाइलेशन, बाइनरीन के असर और अधिकतम ऑप्टिमाइज़ेशन. हालांकि, बाइनरी को पसंद के मुताबिक़ बनाने के लिए ऑप्टिमाइज़ेशन के लिए Wasm के अंदरूनी हिस्से की गहरी जानकारी होना ज़रूरी है. आम तौर पर, डिफ़ॉल्ट सेटिंग पहले से ही बढ़िया काम कर रही हैं. इसके साथ ही, कंपाइल और ऑप्टिमाइज़ करते रहें बाइनरीयन के साथ!

स्वीकार की गई

इस पोस्ट की समीक्षा अलोन ज़काई ने की है, थॉमस लाइवली और रेचल एंड्रयू.