Electron 集成 WebAssembly ​

// scripts/emscripten-setup.js
import { execSync } from 'child_process'
import { existsSync, mkdirSync } from 'fs'

class EmscriptenSetup {
  constructor() {
    this.checkPrerequisites()
  }

  checkPrerequisites() {
    const prerequisites = {
      'Emscripten': this.checkCommand('emcc --version'),
      'Python': this.checkCommand('python --version'),
      'Git': this.checkCommand('git --version'),
    }

    const missing = Object.entries(prerequisites)
      .filter(([, exists]) => !exists)
      .map(([name]) => name)

    if (missing.length > 0) {
      throw new Error(`缺少必要的开发环境: ${missing.join(', ')}`)
    }
  }

  checkCommand(command) {
    try {
      execSync(command, { stdio: 'ignore' })
      return true
    } catch {
      return false
    }
  }

  async compileCToWasm(sourceFile, outputName, options = {}) {
    const defaultOptions = {
      optimization: '-O2',
      wasm: true,
      modularize: true,
      exportFunctions: ['_malloc', '_free'],
      memoryModel: 'MAXIMUM_MEMORY=512MB',
    }

    const mergedOptions = { ...defaultOptions, ...options }

    const command = [
      'emcc',
      sourceFile,
      `-o ${outputName}.js`,
      `-s ${mergedOptions.memoryModel}`,
      mergedOptions.optimization,
      mergedOptions.wasm ? '-s WASM=1' : '',
      mergedOptions.modularize ? '-s MODULARIZE=1' : '',
      `-s EXPORTED_FUNCTIONS="[${mergedOptions.exportFunctions
        .map((f) => `'${f}'`)
        .join(',')}]"`,
      "-s EXPORTED_RUNTIME_METHODS=\"['ccall', 'cwrap']\"",
    ]
      .filter(Boolean)
      .join(' ')

    try {
      console.log(`🔨 编译 ${sourceFile} 为 WebAssembly...`)
      execSync(command, { stdio: 'inherit' })
      console.log('✅ WebAssembly 编译成功')
    } catch (error) {
      console.error('❌ 编译失败:', error.message)
      throw error
    }
  }
}

export const emscriptenSetup = new EmscriptenSetup()

// lib/wasm-loader.js
import { readFile } from 'fs/promises'
import { join, dirname } from 'path'
import { fileURLToPath } from 'url'

class WASMLoader {
  constructor() {
    this.modules = new Map()
    this.loadingPromises = new Map()
    this.__dirname = dirname(fileURLToPath(import.meta.url))
  }

  async loadWASMModule(moduleName, wasmPath, jsPath) {
    if (this.modules.has(moduleName)) {
      return this.modules.get(moduleName)
    }

    if (this.loadingPromises.has(moduleName)) {
      return this.loadingPromises.get(moduleName)
    }

    const loadPromise = this.initializeWASMModule(wasmPath, jsPath)
      .then((module) => {
        this.modules.set(moduleName, module)
        this.loadingPromises.delete(moduleName)
        console.log(`✅ WASM 模块加载成功: ${moduleName}`)
        return module
      })
      .catch((error) => {
        this.loadingPromises.delete(moduleName)
        console.error(`❌ WASM 模块加载失败: ${moduleName}`, error)
        throw error
      })

    this.loadingPromises.set(moduleName, loadPromise)
    return loadPromise
  }

  async initializeWASMModule(wasmPath, jsPath) {
    // 动态导入 Emscripten 生成的 JS 胶水代码
    const moduleFactory = await import(jsPath)

    const moduleConfig = {
      wasmBinary: await this.loadWASMBinary(wasmPath),
      onRuntimeInitialized: () => {
        console.log('WASM 运行时初始化完成')
      },
      print: (text) => console.log(`WASM: ${text}`),
      printErr: (text) => console.error(`WASM Error: ${text}`),
    }

    return moduleFactory(moduleConfig)
  }

  async loadWASMBinary(wasmPath) {
    try {
      const fullPath = join(this.__dirname, wasmPath)
      const wasmBuffer = await readFile(fullPath)
      return wasmBuffer
    } catch (error) {
      console.error('读取 WASM 二进制文件失败:', error)
      throw error
    }
  }

  async callWASMFunction(moduleName, functionName, ...args) {
    const module = await this.getModule(moduleName)

    if (!module[functionName]) {
      throw new Error(`函数 ${functionName} 在模块 ${moduleName} 中不存在`)
    }

    try {
      const result = module[functionName](...args)
      return result
    } catch (error) {
      console.error(`WASM 函数调用失败 [${moduleName}.${functionName}]:`, error)
      throw error
    }
  }

  async getModule(moduleName) {
    if (!this.modules.has(moduleName)) {
      throw new Error(`WASM 模块未加载: ${moduleName}`)
    }
    return this.modules.get(moduleName)
  }

  // 内存管理辅助函数
  createWASMMemory(module, initial = 256, maximum = 2048) {
    return new WebAssembly.Memory({ initial, maximum })
  }

  // 在 JavaScript 和 WASM 之间传递数据
  allocateString(module, str) {
    const encoder = new TextEncoder()
    const bytes = encoder.encode(str)
    const ptr = module._malloc(bytes.length + 1)

    module.HEAPU8.set(bytes, ptr)
    module.HEAPU8[ptr + bytes.length] = 0 // null terminator

    return { ptr, length: bytes.length }
  }

  freeString(module, ptr) {
    if (module._free) {
      module._free(ptr)
    }
  }
}

export const wasmLoader = new WASMLoader()

// preload/wasm-preload.js
import { contextBridge, ipcRenderer } from 'electron'
import { wasmLoader } from '../lib/wasm-loader.js'

class WASMPreloadIntegration {
  constructor() {
    this.initialized = false
    this.init()
  }

  async init() {
    try {
      // 预加载关键 WASM 模块
      await this.preloadCriticalModules()
      this.initialized = true

      console.log('✅ WASM 预加载初始化完成')
    } catch (error) {
      console.error('❌ WASM 预加载初始化失败:', error)
    }
  }

  async preloadCriticalModules() {
    const criticalModules = [
      {
        name: 'mathEngine',
        wasmPath: '../wasm/math-engine.wasm',
        jsPath: '../wasm/math-engine.js',
      },
      {
        name: 'imageProcessor',
        wasmPath: '../wasm/image-processor.wasm',
        jsPath: '../wasm/image-processor.js',
      },
    ]

    await Promise.all(
      criticalModules.map(async ({ name, wasmPath, jsPath }) => {
        await wasmLoader.loadWASMModule(name, wasmPath, jsPath)
      })
    )
  }

  exposeToRenderer() {
    const wasmAPI = {
      // 模块状态检查
      isInitialized: () => this.initialized,

      // 数学计算功能
      calculateDistance: async (x1, y1, x2, y2) => {
        return await wasmLoader.callWASMFunction(
          'mathEngine',
          'calculate_distance',
          x1,
          y1,
          x2,
          y2
        )
      },

      fibonacciSequence: async (n) => {
        const module = await wasmLoader.getModule('mathEngine')
        const ptr = module._fibonacci_sequence(n)

        if (!ptr) throw new Error('内存分配失败')

        try {
          const sequence = []
          for (let i = 0; i < n; i++) {
            sequence.push(module.HEAP32[ptr / 4 + i])
          }
          return sequence
        } finally {
          module._free_memory(ptr)
        }
      },

      // 图像处理功能
      processImage: async (imageData, width, height, operation) => {
        return await wasmLoader.callWASMFunction(
          'imageProcessor',
          'process_image',
          imageData,
          width,
          height,
          operation
        )
      },
    }

    // 安全地暴露到渲染进程
    contextBridge.exposeInMainWorld('wasmAPI', wasmAPI)
  }
}

const wasmPreload = new WASMPreloadIntegration()
wasmPreload.exposeToRenderer()

// lib/wasm-data-exchange.js
export class WASMDataExchange {
  constructor(wasmModule) {
    this.module = wasmModule
    this.allocations = new Set()
  }

  // 传输数组到 WASM
  transferArrayToWASM(jsArray, dataType = 'float') {
    const typeInfo = {
      'int8': { heap: this.module.HEAP8, bytesPerElement: 1 },
      'int16': { heap: this.module.HEAP16, bytesPerElement: 2 },
      'int32': { heap: this.module.HEAP32, bytesPerElement: 4 },
      'float': { heap: this.module.HEAPF32, bytesPerElement: 4 },
      'double': { heap: this.module.HEAPF64, bytesPerElement: 8 },
    }

    const info = typeInfo[dataType]
    if (!info) {
      throw new Error(`不支持的数据类型: ${dataType}`)
    }

    const bytes = jsArray.length * info.bytesPerElement
    const ptr = this.module._malloc(bytes)

    if (!ptr) {
      throw new Error('内存分配失败')
    }

    this.allocations.add(ptr)
    info.heap.set(jsArray, ptr / info.bytesPerElement)

    return { ptr, length: jsArray.length, dataType }
  }

  // 从 WASM 检索数组
  retrieveArrayFromWASM(ptr, length, dataType = 'float') {
    const typeInfo = {
      'int8': { heap: this.module.HEAP8, bytesPerElement: 1 },
      'int16': { heap: this.module.HEAP16, bytesPerElement: 2 },
      'int32': { heap: this.module.HEAP32, bytesPerElement: 4 },
      'float': { heap: this.module.HEAPF32, bytesPerElement: 4 },
      'double': { heap: this.module.HEAPF64, bytesPerElement: 8 },
    }

    const info = typeInfo[dataType]
    if (!info) {
      throw new Error(`不支持的数据类型: ${dataType}`)
    }

    const result = []
    const startIndex = ptr / info.bytesPerElement

    for (let i = 0; i < length; i++) {
      result.push(info.heap[startIndex + i])
    }

    return result
  }

  // 传输二维矩阵到 WASM
  transferMatrixToWASM(matrix, dataType = 'float') {
    const flattened = matrix.flat()
    const arrayInfo = this.transferArrayToWASM(flattened, dataType)

    return {
      ...arrayInfo,
      rows: matrix.length,
      cols: matrix[0].length,
    }
  }

  // 处理字符串数据
  transferStringToWASM(str) {
    const encoder = new TextEncoder()
    const bytes = encoder.encode(str)
    const ptr = this.module._malloc(bytes.length + 1)

    if (!ptr) {
      throw new Error('字符串内存分配失败')
    }

    this.allocations.add(ptr)
    this.module.HEAPU8.set(bytes, ptr)
    this.module.HEAPU8[ptr + bytes.length] = 0 // Null terminator

    return { ptr, length: bytes.length }
  }

  // 清理内存
  free(ptr) {
    if (this.allocations.has(ptr)) {
      this.module._free(ptr)
      this.allocations.delete(ptr)
    }
  }

  // 清理所有分配的内存
  cleanup() {
    for (const ptr of this.allocations) {
      this.module._free(ptr)
    }
    this.allocations.clear()
  }

  // 内存使用统计
  getMemoryUsage() {
    const memory =
      this.module._get_memory_usage && this.module._get_memory_usage()
    return {
      allocations: this.allocations.size,
      totalMemory: memory ? memory.total : '未知',
      usedMemory: memory ? memory.used : '未知',
    }
  }
}

// lib/wasm-thread-manager.js
import { Worker } from 'worker_threads'

export class WASMThreadManager {
  constructor() {
    this.workers = new Map()
    this.taskQueue = new Map()
    this.workerScript = join(
      dirname(fileURLToPath(import.meta.url)),
      'wasm-worker.js'
    )
  }

  // 创建专用 WASM 工作线程
  async createWorker(workerId, moduleName, wasmPath, jsPath) {
    const worker = new Worker(this.workerScript, {
      workerData: {
        workerId,
        moduleName,
        wasmPath,
        jsPath,
      },
    })

    this.workers.set(workerId, worker)

    worker.on('message', (result) => {
      this.handleWorkerResult(workerId, result)
    })

    worker.on('error', (error) => {
      console.error(`WASM 工作线程错误 [${workerId}]:`, error)
      this.workers.delete(workerId)
    })

    worker.on('exit', (code) => {
      if (code !== 0) {
        console.warn(`WASM 工作线程退出 [${workerId}], 代码: ${code}`)
      }
      this.workers.delete(workerId)
    })

    // 等待 worker 初始化完成
    return new Promise((resolve) => {
      worker.once('online', () => {
        console.log(`✅ WASM 工作线程就绪: ${workerId}`)
        resolve(workerId)
      })
    })
  }

  // 提交任务到工作线程
  async submitTask(workerId, taskType, data, timeout = 30000) {
    return new Promise((resolve, reject) => {
      const taskId = `task-${Date.now()}-${Math.random()
        .toString(36)
        .substr(2, 9)}`

      const timeoutId = setTimeout(() => {
        reject(new Error(`WASM 任务执行超时: ${taskId}`))
        this.taskQueue.delete(taskId)
      }, timeout)

      this.taskQueue.set(taskId, { resolve, reject, timeoutId })

      const worker = this.workers.get(workerId)
      if (!worker) {
        reject(new Error(`WASM 工作线程不存在: ${workerId}`))
        return
      }

      worker.postMessage({ taskId, taskType, data })
    })
  }

  handleWorkerResult(workerId, result) {
    const { taskId, data, error } = result
    const task = this.taskQueue.get(taskId)

    if (!task) {
      console.warn(`未知任务 ID: ${taskId}`)
      return
    }

    clearTimeout(task.timeoutId)
    this.taskQueue.delete(taskId)

    if (error) {
      task.reject(new Error(error))
    } else {
      task.resolve(data)
    }
  }

  // 并行处理批量数据
  async processBatchData(workerId, dataArray, processFunction) {
    const batchPromises = dataArray.map((data, index) =>
      this.submitTask(workerId, processFunction, { data, index })
    )

    const results = await Promise.all(batchPromises)
    return results.sort((a, b) => a.index - b.index).map((r) => r.result)
  }

  // 优雅关闭所有工作线程
  async shutdown() {
    const shutdownPromises = Array.from(this.workers.values()).map((worker) => {
      return new Promise((resolve) => {
        worker.once('exit', () => resolve())
        worker.postMessage({ type: 'shutdown' })

        // 强制终止（如果 5 秒内没有正常退出）
        setTimeout(() => {
          worker.terminate()
          resolve()
        }, 5000)
      })
    })

    await Promise.all(shutdownPromises)
    this.workers.clear()
    this.taskQueue.clear()

    console.log('✅ 所有 WASM 工作线程已关闭')
  }
}

// lib/wasm-worker.js
import { workerData, parentPort, isMainThread } from 'worker_threads'
import { wasmLoader } from './wasm-loader.js'

class WASMWorker {
  constructor(workerId, moduleName, wasmPath, jsPath) {
    this.workerId = workerId
    this.moduleName = moduleName
    this.wasmPath = wasmPath
    this.jsPath = jsPath
    this.module = null
    this.isShuttingDown = false

    this.initialize()
  }

  async initialize() {
    try {
      this.module = await wasmLoader.loadWASMModule(
        this.moduleName,
        this.wasmPath,
        this.jsPath
      )

      console.log(`✅ WASM 工作线程初始化完成: ${this.workerId}`)

      // 通知主线程初始化完成
      if (parentPort) {
        parentPort.postMessage({ type: 'initialized', workerId: this.workerId })
      }
    } catch (error) {
      console.error(`WASM 工作线程初始化失败: ${this.workerId}`, error)
      process.exit(1)
    }
  }

  async processTask(taskType, data) {
    if (this.isShuttingDown) {
      throw new Error('工作线程正在关闭')
    }

    try {
      switch (taskType) {
        case 'matrix_multiply':
          return await this.processMatrixMultiplication(data)

        case 'image_filter':
          return await this.processImageFilter(data)

        case 'data_transform':
          return await this.processDataTransform(data)

        default:
          throw new Error(`未知任务类型: ${taskType}`)
      }
    } catch (error) {
      console.error(`WASM 任务处理失败 [${taskType}]:`, error)
      throw error
    }
  }

  async processMatrixMultiplication({ matrixA, matrixB }) {
    const exchange = new WASMDataExchange(this.module)

    try {
      const matrixAInfo = exchange.transferMatrixToWASM(matrixA)
      const matrixBInfo = exchange.transferMatrixToWASM(matrixB)

      const resultPtr = this.module._multiply_matrices(
        matrixAInfo.ptr,
        matrixAInfo.rows,
        matrixAInfo.cols,
        matrixBInfo.ptr,
        matrixBInfo.rows,
        matrixBInfo.cols
      )

      const result = exchange.retrieveArrayFromWASM(
        resultPtr,
        matrixAInfo.rows * matrixBInfo.cols
      )

      // 重组为二维矩阵
      const resultMatrix = []
      for (let i = 0; i < matrixAInfo.rows; i++) {
        resultMatrix.push(
          result.slice(i * matrixBInfo.cols, (i + 1) * matrixBInfo.cols)
        )
      }

      return resultMatrix
    } finally {
      exchange.cleanup()
    }
  }

  async processImageFilter({ imageData, width, height, filterType }) {
    const exchange = new WASMDataExchange(this.module)

    try {
      const imageInfo = exchange.transferArrayToWASM(imageData, 'int8')

      const resultPtr = this.module._apply_image_filter(
        imageInfo.ptr,
        width,
        height,
        filterType
      )

      const resultData = exchange.retrieveArrayFromWASM(
        resultPtr,
        imageData.length,
        'int8'
      )

      return resultData
    } finally {
      exchange.cleanup()
    }
  }
}

// 工作线程主逻辑
if (!isMainThread && parentPort) {
  const worker = new WASMWorker(
    workerData.workerId,
    workerData.moduleName,
    workerData.wasmPath,
    workerData.jsPath
  )

  parentPort.on('message', async (message) => {
    if (message.type === 'shutdown') {
      worker.isShuttingDown = true
      return
    }

    const { taskId, taskType, data } = message

    try {
      const result = await worker.processTask(taskType, data)
      parentPort.postMessage({ taskId, data: result })
    } catch (error) {
      parentPort.postMessage({
        taskId,
        error: error.message,
      })
    }
  })
}

// applications/scientific-computing.js
import { wasmLoader } from '../lib/wasm-loader.js'
import { WASMDataExchange } from '../lib/wasm-data-exchange.js'

export class ScientificComputing {
  constructor() {
    this.module = null
    this.initialized = false
  }

  async initialize() {
    this.module = await wasmLoader.loadWASMModule(
      'scientific',
      '../wasm/scientific.wasm',
      '../wasm/scientific.js'
    )
    this.exchange = new WASMDataExchange(this.module)
    this.initialized = true
  }

  // 快速傅里叶变换
  async fft(signalData) {
    await this.ensureInitialized()

    const signalInfo = this.exchange.transferArrayToWASM(signalData, 'float')

    try {
      const resultPtr = this.module._fft_transform(
        signalInfo.ptr,
        signalInfo.length
      )
      const result = this.exchange.retrieveArrayFromWASM(
        resultPtr,
        signalInfo.length,
        'float'
      )

      // 转换为复数表示 [real, imag, real, imag, ...]
      const complexResult = []
      for (let i = 0; i < result.length; i += 2) {
        complexResult.push({
          real: result[i],
          imag: result[i + 1],
        })
      }

      return complexResult
    } finally {
      this.exchange.cleanup()
    }
  }

  // 数值积分
  async numericalIntegration(fn, a, b, steps = 1000) {
    await this.ensureInitialized()

    // 使用梯形法则进行数值积分
    const stepSize = (b - a) / steps
    const xValues = []

    for (let i = 0; i <= steps; i++) {
      xValues.push(a + i * stepSize)
    }

    const xInfo = this.exchange.transferArrayToWASM(xValues, 'float')

    try {
      const result = this.module._trapezoidal_integral(
        xInfo.ptr,
        xInfo.length,
        stepSize
      )
      return result
    } finally {
      this.exchange.free(xInfo.ptr)
    }
  }

  // 线性回归分析
  async linearRegression(xData, yData) {
    await this.ensureInitialized()

    const xInfo = this.exchange.transferArrayToWASM(xData, 'float')
    const yInfo = this.exchange.transferArrayToWASM(yData, 'float')

    try {
      const resultPtr = this.module._linear_regression(
        xInfo.ptr,
        yInfo.ptr,
        xInfo.length
      )

      const result = this.exchange.retrieveArrayFromWASM(resultPtr, 2, 'float')

      return {
        slope: result[0],
        intercept: result[1],
      }
    } finally {
      this.exchange.cleanup()
    }
  }

  async ensureInitialized() {
    if (!this.initialized) {
      await this.initialize()
    }
  }
}

// lib/wasm-performance.js
import { performance, PerformanceObserver } from 'perf_hooks'

export class WASMPerformanceMonitor {
  constructor() {
    this.metrics = new Map()
    this.observer = new PerformanceObserver((list) => {
      this.processPerformanceEntries(list.getEntries())
    })

    this.startMonitoring()
  }

  startMonitoring() {
    this.observer.observe({ entryTypes: ['measure', 'function'] })
  }

  // 包装 WASM 函数调用以进行性能监控
  instrumentWASMFunction(moduleName, functionName, wasmFunction) {
    return async (...args) => {
      const startMark = `wasm-${moduleName}-${functionName}-start`
      const endMark = `wasm-${moduleName}-${functionName}-end`
      const measureName = `wasm-${moduleName}-${functionName}`

      performance.mark(startMark)

      try {
        const result = await wasmFunction(...args)
        performance.mark(endMark)
        performance.measure(measureName, startMark, endMark)

        this.recordSuccess(moduleName, functionName)
        return result
      } catch (error) {
        performance.mark(endMark)
        performance.measure(measureName, startMark, endMark)

        this.recordError(moduleName, functionName, error)
        throw error
      }
    }
  }

  processPerformanceEntries(entries) {
    entries.forEach((entry) => {
      if (entry.name.startsWith('wasm-')) {
        const [_, moduleName, functionName] = entry.name.split('-')

        if (!this.metrics.has(moduleName)) {
          this.metrics.set(moduleName, new Map())
        }

        const moduleMetrics = this.metrics.get(moduleName)

        if (!moduleMetrics.has(functionName)) {
          moduleMetrics.set(functionName, {
            callCount: 0,
            totalTime: 0,
            averageTime: 0,
            minTime: Infinity,
            maxTime: 0,
            errorCount: 0,
            successCount: 0,
          })
        }

        const metrics = moduleMetrics.get(functionName)
        metrics.callCount++
        metrics.totalTime += entry.duration
        metrics.averageTime = metrics.totalTime / metrics.callCount
        metrics.minTime = Math.min(metrics.minTime, entry.duration)
        metrics.maxTime = Math.max(metrics.maxTime, entry.duration)
      }
    })
  }

  recordSuccess(moduleName, functionName) {
    this.updateMetrics(moduleName, functionName, 'success')
  }

  recordError(moduleName, functionName, error) {
    this.updateMetrics(moduleName, functionName, 'error')
    console.error(`WASM 函数调用错误 [${moduleName}.${functionName}]:`, error)
  }

  updateMetrics(moduleName, functionName, type) {
    if (!this.metrics.has(moduleName)) {
      this.metrics.set(moduleName, new Map())
    }

    const moduleMetrics = this.metrics.get(moduleName)

    if (!moduleMetrics.has(functionName)) {
      moduleMetrics.set(functionName, {
        callCount: 0,
        totalTime: 0,
        averageTime: 0,
        minTime: Infinity,
        maxTime: 0,
        errorCount: 0,
        successCount: 0,
      })
    }

    const metrics = moduleMetrics.get(functionName)

    if (type === 'success') {
      metrics.successCount++
    } else if (type === 'error') {
      metrics.errorCount++
    }
  }

  // 生成性能报告
  generatePerformanceReport() {
    const report = {
      timestamp: new Date().toISOString(),
      modules: {},
    }

    for (const [moduleName, functions] of this.metrics) {
      report.modules[moduleName] = {}

      for (const [functionName, metrics] of functions) {
        report.modules[moduleName][functionName] = {
          ...metrics,
          successRate:
            metrics.callCount > 0
              ? (metrics.successCount / metrics.callCount) * 100
              : 0,
        }
      }
    }

    return report
  }

  // 识别性能瓶颈
  identifyBottlenecks() {
    const bottlenecks = []
    const report = this.generatePerformanceReport()

    for (const [moduleName, functions] of Object.entries(report.modules)) {
      for (const [functionName, metrics] of Object.entries(functions)) {
        if (metrics.averageTime > 100) {
          // 超过 100ms 认为是瓶颈
          bottlenecks.push({
            module: moduleName,
            function: functionName,
            averageTime: metrics.averageTime,
            callCount: metrics.callCount,
            severity: metrics.averageTime > 500 ? 'HIGH' : 'MEDIUM',
          })
        }
      }
    }

    return bottlenecks.sort((a, b) => b.averageTime - a.averageTime)
  }
}

export const wasmPerformance = new WASMPerformanceMonitor()