Jassif Team Institution

console.log(typeof WebAssembly === 'object');
console.log(WebAssembly);

const fs = require('fs');

// Read the WebAssembly binary file
const wasmBuffer = fs.readFileSync('./simple.wasm');

// Compile and instantiate the module
WebAssembly.instantiate(wasmBuffer).then(result => {
  const instance = result.instance;
  
  // Call the exported 'add' function
  const sum = instance.exports.add(2, 3);
  console.log('2 + 3 =', sum); // Output: 2 + 3 = 5
});

#include 

EMSCRIPTEN_KEEPALIVE
int add(int a, int b) {
  return a + b;
}

emcc add.c -s WASM=1 -s EXPORTED_FUNCTIONS='["_add"]' -o add.js

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn add(a: i32, b: i32) -> i32 {
   a + b
}

wasm-pack build --target nodejs

// JavaScript code
const wasmModule = await WebAssembly.instantiate(wasmBuffer, {
  env: {
    memory: new WebAssembly.Memory({ initial: 1 })
  }
});
// Allocate memory for an array of 10 integers (4 bytes each)
const arraySize = 10;
const ptr = wasmModule.exports.alloc(arraySize * 4);
const intArray = new Int32Array(wasmModule.exports.memory.buffer, ptr, arraySize);
// Fill array with values
for (let i = 0; i < arraySize; i++) {
  intArray[i] = i * 2;
}
// Call WebAssembly function to process the array
const sum = wasmModule.exports.processArray(ptr, arraySize);
console.log('Sum of array:', sum);
// Don't forget to free the memory
wasmModule.exports.dealloc(ptr, arraySize * 4);

#include 

int* alloc(int size) {
  return (int*)malloc(size);
}

void dealloc(int* ptr, int size) {
  free(ptr);
}

int processArray(int* array, int length) {
  int sum = 0;
  for (int i = 0; i < length; i++) {
    sum += array[i];
  }
  return sum;
}

// main.js
const workerCode = `
  const wasmModule = await WebAssembly.instantiate(wasmBuffer, {
    env: { memory: new WebAssembly.Memory({ initial: 1, shared: true }) }
  });

  self.onmessage = (e) => {
    const { data, start, end } = e.data;
    const result = wasmModule.exports.processChunk(data, start, end);
    self.postMessage({ result });
  };
`;

// Create worker pool
const workerCount = navigator.hardwareConcurrency || 4;
const workers = Array(workerCount).fill().map(() => {
  const blob = new Blob([workerCode], { type: 'application/javascript' });
  return new Worker(URL.createObjectURL(blob));
});

// Process data in parallel
async function processInParallel(data, chunkSize) {
  const results = [];
  let completed = 0;

  return new Promise((resolve) => {
    workers.forEach((worker, i) => {
      const start = i * chunkSize;
      const end = Math.min(start + chunkSize, data.length);

      worker.onmessage = (e) => {
        results[i] = e.data.result;
        completed++;

        if (completed === workerCount) {
          resolve(results);
        }
      };

      worker.postMessage({ data, start, end });
    });
  });
}

# Compile with debugging information and source maps
emcc -g4 --source-map-base http://localhost:8080/ -s WASM=1 -s EXPORTED_FUNCTIONS='["_main","_my_function"]' -o output.html source.c

// JavaScript wrapper for WebAssembly image processing
async function applyFilter(imageData, filterType) {
  const { instance } = await WebAssembly.instantiate(wasmBuffer, {
    env: { memory: new WebAssembly.Memory({ initial: 1 }) }
  });

  const { width, height, data } = imageData;

  // Allocate memory for image data
  const imageDataSize = width * height * 4; // RGBA
  const imageDataPtr = instance.exports.alloc(imageDataSize);

  // Copy image data to WebAssembly memory
  const wasmMemory = new Uint8Array(instance.exports.memory.buffer);
  wasmMemory.set(new Uint8Array(data.buffer), imageDataPtr);

  // Apply filter
  instance.exports.applyFilter(imageDataPtr, width, height, filterType);

  // Copy result back to ImageData
  const resultData = new Uint8ClampedArray(
    wasmMemory.slice(imageDataPtr, imageDataPtr + imageDataSize)
  );

  // Free allocated memory
  instance.exports.dealloc(imageDataPtr, imageDataSize);

  return new ImageData(resultData, width, height);
}

// Example: Using the Web Crypto API with WebAssembly
async function encryptData(data, keyMaterial) {
  // Import WebAssembly crypto module
  const { instance } = await WebAssembly.instantiateStreaming(
    fetch('crypto.wasm'),
    { env: { memory: new WebAssembly.Memory({ initial: 1 }) } }
  );

  // Generate IV (Initialization Vector)
  const iv = window.crypto.getRandomValues(new Uint8Array(12));

  // Prepare data
  const dataBytes = new TextEncoder().encode(JSON.stringify(data));
  const dataPtr = instance.exports.alloc(dataBytes.length);
  new Uint8Array(instance.exports.memory.buffer, dataPtr, dataBytes.length)
    .set(dataBytes);

  // Encrypt data using WebAssembly
  const encryptedDataPtr = instance.exports.encrypt(dataPtr, dataBytes.length);

  // Get encrypted data from WebAssembly memory
  const encryptedData = new Uint8Array(
    instance.exports.memory.buffer,
    encryptedDataPtr,
    dataBytes.length // In real usage, you'd track the actual encrypted size
  );

  // Clean up
  instance.exports.dealloc(dataPtr, dataBytes.length);

  return {
    iv: Array.from(iv),
    encryptedData: Array.from(encryptedData)
  };
}

// Recursive Fibonacci in JavaScript (inefficient for demonstration)
function fibonacciJS(n) {
  if (n <= 1) return n;
  return fibonacciJS(n - 1) + fibonacciJS(n - 2);
}

#include 

// WebAssembly-optimized Fibonacci function
EMSCRIPTEN_KEEPALIVE
int fibonacci_wasm(int n) {
  if (n <= 1) return n;
  
  int a = 0, b = 1, temp;
  for (int i = 2; i <= n; i++) {
    temp = a + b;
    a = b;
    b = temp;
  }
  
  return b;
}

const fs = require('fs');
const path = require('path');

// Read the WebAssembly binary file
const wasmBuffer = fs.readFileSync('./fibonacci.wasm');

// JavaScript implementation for comparison
function fibonacciJS(n) {
  if (n <= 1) return n;
  return fibonacciJS(n - 1) + fibonacciJS(n - 2);
}

// Compile and instantiate the WebAssembly module
WebAssembly.instantiate(wasmBuffer).then(result => {
  const { fibonacci_wasm } = result.instance.exports;
  
  // Test with a value that's computationally expensive
  const n = 40;
  
  // Measure WebAssembly performance
  const wasmStart = performance.now();
  const wasmResult = fibonacci_wasm(n);
  const wasmEnd = performance.now();
  
  // Measure JavaScript performance
  const jsStart = performance.now();
  const jsResult = fibonacciJS(n);
  const jsEnd = performance.now();
  
  console.log(`Fibonacci(${n})`);
  console.log(`WebAssembly: ${wasmResult} (${(wasmEnd - wasmStart).toFixed(2)} ms)`);
  console.log(`JavaScript: ${jsResult} (${(jsEnd - jsStart).toFixed(2)} ms)`);
});

// Create a new WebAssembly Memory instance with 1 page (64KB) initially,
// and a maximum of 10 pages (640KB)
const memory = new WebAssembly.Memory({
  initial: 1,
  maximum: 10
});

// Access the memory as a typed array in JavaScript
let bytes = new Uint8Array(memory.buffer);

// Write data to memory
for (let i = 0; i < 10; i++) {
  bytes[i] = i * 10; // Write values 0, 10, 20, ..., 90
}

// Read data from memory
console.log('Memory contents:', bytes.slice(0, 10));

// Grow the memory by 1 page (returns the previous size in pages)
const previousPages = memory.grow(1);
console.log(`Memory grown from ${previousPages} to ${memory.buffer.byteLength / 65536} pages`);

// IMPORTANT: After growing memory, we need to create a new view
// because the ArrayBuffer is detached when memory grows
bytes = new Uint8Array(memory.buffer);
console.log('Memory size now:', bytes.length, 'bytes');

const memory = new WebAssembly.Memory({ initial: 1 });

// Different views of the same memory
const bytes = new Uint8Array(memory.buffer); // Unsigned 8-bit integers
const ints = new Int32Array(memory.buffer); // Signed 32-bit integers
const floats = new Float32Array(memory.buffer); // 32-bit floating point

// Write an integer at the beginning of memory
ints[0] = 42;

// The same memory location viewed as bytes
console.log('42 as bytes:', Array.from(bytes.slice(0, 4)));

// Write a float
floats[1] = 3.14159;

// View the float as bytes and as an integer
const floatByteOffset = 1 * Float32Array.BYTES_PER_ELEMENT;
const floatIntValue = ints[floatByteOffset / Int32Array.BYTES_PER_ELEMENT];
console.log('3.14159 as bytes:', Array.from(bytes.slice(floatByteOffset, floatByteOffset + 4)));
console.log('3.14159 as int32:', floatIntValue);

#include 
#include 

// WebAssembly optimized grayscale conversion
EMSCRIPTEN_KEEPALIVE
void grayscale_wasm(uint8_t* pixels, int length) {
  // Process each pixel (RGBA format)
  for (int i = 0; i < length; i += 4) {
    // Calculate grayscale value using luminance formula
    uint8_t gray = (uint8_t)(
      (0.299 * pixels[i]) +     // Red
      (0.587 * pixels[i + 1]) + // Green
      (0.114 * pixels[i + 2])   // Blue
    );
    
    // Set RGB channels to gray value
    pixels[i] = gray;     // Red
    pixels[i + 1] = gray; // Green
    pixels[i + 2] = gray; // Blue
    // Alpha channel (pixels[i + 3]) remains unchanged
  }
}

const fs = require('fs');
const wasmBuffer = fs.readFileSync('./image_processing.wasm');

// Sample image data (RGBA format, 2x2 pixel image)
const imageData = new Uint8Array([
  255, 0, 0, 255,    // Red pixel
  0, 255, 0, 255,    // Green pixel
  0, 0, 255, 255,    // Blue pixel
  255, 255, 0, 255   // Yellow pixel
]);

// Instantiate the WebAssembly module
WebAssembly.instantiate(wasmBuffer, {
  env: {
    memory: new WebAssembly.Memory({ initial: 1 })
  }
}).then(result => {
  const instance = result.instance;
  const { grayscale_wasm } = instance.exports;
  const memory = instance.exports.memory;
  
  // Get a view of the WebAssembly memory
  const wasmMemory = new Uint8Array(memory.buffer);
  
  // Copy image data to WebAssembly memory
  wasmMemory.set(imageData);
  
  // Process the image (convert to grayscale)
  grayscale_wasm(0, imageData.length);
  
  // Get processed image data from WebAssembly memory
  const processedData = wasmMemory.slice(0, imageData.length);
  
  console.log('Original image:', imageData);
  console.log('Grayscale image:', processedData);
});

const fs = require('fs');
const wasmBuffer = fs.readFileSync('./math.wasm');

// JavaScript function that will use WebAssembly
async function calculateFactorial(n) {
  // Instantiate the module
  const result = await WebAssembly.instantiate(wasmBuffer);
  const wasm = result.instance.exports;
  
  // Use the WebAssembly factorial function
  return wasm.factorial(n);
}

// Use our mixed JS/WebAssembly function
async function main() {
  console.log('Calculating factorials:');
  for (let i = 1; i <= 10; i++) {
    const result = await calculateFactorial(i);
    console.log(`${i}! = ${result}`);
  }
}

main().catch(console.error);