1. 环境配置验证脚本:

#!/bin/bash
# verify_emscripten.sh

echo "验证 Emscripten 环境..."

# 检查版本
echo "Emscripten 版本:"
emcc --version

echo -e "\nClang 版本:"
emcc --version | head -1

echo -e "\nNode.js 版本:"
node --version

echo -e "\nPython 版本:"
python3 --version

# 测试基本编译
echo -e "\n编译测试程序..."
echo 'int main() { return 42; }' > test.c
emcc test.c -o test.html
if [ -f "test.html" ]; then
    echo "✅ 基本编译测试成功"
    rm test.c test.html test.js test.wasm
else
    echo "❌ 基本编译测试失败"
fi

2. 时间戳程序 (timestamp.c):

#include <stdio.h>
#include <time.h>
#include <emscripten.h>

EMSCRIPTEN_KEEPALIVE
double get_current_timestamp() {
    return emscripten_get_now();
}

EMSCRIPTEN_KEEPALIVE
void print_current_time() {
    time_t rawtime;
    struct tm* timeinfo;
    
    time(&rawtime);
    timeinfo = localtime(&rawtime);
    
    printf("当前时间: %s", asctime(timeinfo));
    printf("时间戳: %.3f ms\n", emscripten_get_now());
}

int main() {
    printf("C 程序启动\n");
    print_current_time();
    return 0;
}

3. 编译脚本 (build_timestamp.sh):

#!/bin/bash
# build_timestamp.sh

echo "编译时间戳程序为不同格式..."

# 编译为 HTML 格式
echo "编译为 HTML..."
emcc timestamp.c -o timestamp.html \
  -s EXPORTED_FUNCTIONS='["_get_current_timestamp","_print_current_time"]' \
  -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap"]'

# 编译为 JS 格式
echo "编译为 JS..."
emcc timestamp.c -o timestamp.js \
  -s EXPORTED_FUNCTIONS='["_get_current_timestamp","_print_current_time"]' \
  -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap"]'

# 编译为纯 WASM
echo "编译为纯 WASM..."
emcc timestamp.c -o timestamp.wasm --no-entry \
  -s EXPORTED_FUNCTIONS='["_get_current_timestamp","_print_current_time"]' \
  -s STANDALONE_WASM

# 显示文件大小
echo -e "\n文件大小对比:"
ls -lh timestamp.html timestamp.js timestamp.wasm | awk '{print $5 "\t" $9}'

4. JavaScript 测试接口:

// test_timestamp.js
Module.onRuntimeInitialized = function() {
    console.log('WebAssembly 模块已加载');
    
    // 包装函数
    const getCurrentTimestamp = Module.cwrap('get_current_timestamp', 'number', []);
    const printCurrentTime = Module.cwrap('print_current_time', null, []);
    
    // 测试函数调用
    console.log('JavaScript 获取的时间戳:', Date.now());
    console.log('WASM 获取的时间戳:', getCurrentTimestamp());
    
    printCurrentTime();
    
    // 性能对比
    const iterations = 10000;
    
    // JavaScript 时间戳
    console.time('JS timestamp');
    for (let i = 0; i < iterations; i++) {
        Date.now();
    }
    console.timeEnd('JS timestamp');
    
    // WASM 时间戳
    console.time('WASM timestamp');
    for (let i = 0; i < iterations; i++) {
        getCurrentTimestamp();
    }
    console.timeEnd('WASM timestamp');
};

预期结果:

• HTML 文件: ~2-5 KB (包含完整运行环境)
• JS 文件: ~100-200 KB (胶水代码 + WASM)
• WASM 文件: ~1-2 KB (仅二进制代码)

1. 测试程序 (optimization_test.c):

#include <emscripten.h>
#include <math.h>

EMSCRIPTEN_KEEPALIVE
double compute_pi(int iterations) {
    double pi = 0.0;
    for (int i = 0; i < iterations; i++) {
        double term = 1.0 / (2 * i + 1);
        if (i % 2 == 0) {
            pi += term;
        } else {
            pi -= term;
        }
    }
    return pi * 4.0;
}

EMSCRIPTEN_KEEPALIVE
double complex_calculation(int n) {
    double result = 0.0;
    for (int i = 1; i <= n; i++) {
        result += sqrt(i) * sin(i) * cos(i) / log(i + 1);
    }
    return result;
}

EMSCRIPTEN_KEEPALIVE
void matrix_multiply(double* a, double* b, double* c, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            double sum = 0.0;
            for (int k = 0; k < n; k++) {
                sum += a[i * n + k] * b[k * n + j];
            }
            c[i * n + j] = sum;
        }
    }
}

int main() {
    printf("优化测试程序\n");
    return 0;
}

2. 优化等级编译脚本 (test_optimization.sh):

#!/bin/bash
# test_optimization.sh

echo "测试不同优化等级的效果..."

# 定义编译选项
declare -a OPT_LEVELS=("-O0" "-O1" "-O2" "-O3" "-Os" "-Oz")
declare -a OPT_NAMES=("无优化" "基础优化" "标准优化" "激进优化" "体积优化" "极致体积优化")

# 导出函数列表
EXPORTS='-s EXPORTED_FUNCTIONS=["_compute_pi","_complex_calculation","_matrix_multiply"]'
RUNTIME='-s EXPORTED_RUNTIME_METHODS=["ccall","cwrap"]'

echo "编译选项\t文件大小\t编译时间"
echo "----------------------------------------"

for i in "${!OPT_LEVELS[@]}"; do
    opt="${OPT_LEVELS[$i]}"
    name="${OPT_NAMES[$i]}"
    
    echo -n "${name} (${opt})\t"
    
    # 计时编译
    start_time=$(date +%s.%N)
    emcc optimization_test.c $opt -o "test_${opt//-/}.js" $EXPORTS $RUNTIME 2>/dev/null
    end_time=$(date +%s.%N)
    
    compile_time=$(echo "$end_time - $start_time" | bc)
    file_size=$(ls -lh "test_${opt//-/}.js" | awk '{print $5}')
    
    echo -e "${file_size}\t\t${compile_time}s"
done

echo -e "\n详细文件信息:"
ls -lh test_*.js | awk '{print $5 "\t" $9}'

3. 性能测试 HTML:

<!DOCTYPE html>
<html>
<head>
    <title>优化等级性能测试</title>
</head>
<body>
    <h1>优化等级性能测试</h1>
    <div id="results"></div>
    
    <script>
    const results = document.getElementById('results');
    
    async function testOptimization(filename, optName) {
        return new Promise((resolve) => {
            const script = document.createElement('script');
            script.src = filename;
            script.onload = () => {
                Module.onRuntimeInitialized = () => {
                    const computePi = Module.cwrap('compute_pi', 'number', ['number']);
                    const complexCalc = Module.cwrap('complex_calculation', 'number', ['number']);
                    
                    // 性能测试
                    const iterations = 1000000;
                    
                    // 测试 Pi 计算
                    const start1 = performance.now();
                    const pi = computePi(iterations);
                    const end1 = performance.now();
                    
                    // 测试复杂计算
                    const start2 = performance.now();
                    const complex = complexCalc(10000);
                    const end2 = performance.now();
                    
                    resolve({
                        name: optName,
                        piTime: end1 - start1,
                        complexTime: end2 - start2,
                        piResult: pi,
                        complexResult: complex
                    });
                };
            };
            document.head.appendChild(script);
        });
    }
    
    async function runAllTests() {
        const tests = [
            { file: 'test_O0.js', name: '无优化 (-O0)' },
            { file: 'test_O1.js', name: '基础优化 (-O1)' },
            { file: 'test_O2.js', name: '标准优化 (-O2)' },
            { file: 'test_O3.js', name: '激进优化 (-O3)' },
            { file: 'test_Os.js', name: '体积优化 (-Os)' },
            { file: 'test_Oz.js', name: '极致体积优化 (-Oz)' }
        ];
        
        results.innerHTML = '<h2>测试进行中...</h2>';
        
        const testResults = [];
        for (const test of tests) {
            try {
                const result = await testOptimization(test.file, test.name);
                testResults.push(result);
                console.log(`完成测试: ${test.name}`);
            } catch (e) {
                console.error(`测试失败: ${test.name}`, e);
            }
        }
        
        // 显示结果
        let html = '<h2>性能测试结果</h2><table border="1"><tr><th>优化等级</th><th>Pi计算时间(ms)</th><th>复杂计算时间(ms)</th><th>Pi值</th></tr>';
        
        testResults.forEach(result => {
            html += `<tr>
                <td>${result.name}</td>
                <td>${result.piTime.toFixed(2)}</td>
                <td>${result.complexTime.toFixed(2)}</td>
                <td>${result.piResult.toFixed(6)}</td>
            </tr>`;
        });
        
        html += '</table>';
        results.innerHTML = html;
    }
    
    // 页面加载后开始测试
    // runAllTests();
    </script>
</body>
</html>

预期结果分析:

• 文件大小: O0 > O1 > O2 ≈ O3 > Os > Oz
• 执行性能: O3 ≈ O2 > O1 > Os ≈ Oz > O0
• 编译时间: O0 < O1 < O2 < O3/Os/Oz

1. 动态数组实现 (dynamic_array.c):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <emscripten.h>

typedef struct {
    int* data;
    size_t size;
    size_t capacity;
    size_t total_allocated;
} DynamicArray;

// 全局内存统计
static size_t global_memory_used = 0;
static size_t global_allocations = 0;
static size_t global_deallocations = 0;

EMSCRIPTEN_KEEPALIVE
DynamicArray* create_array(size_t initial_capacity) {
    DynamicArray* arr = malloc(sizeof(DynamicArray));
    if (!arr) return NULL;
    
    arr->data = malloc(initial_capacity * sizeof(int));
    if (!arr->data) {
        free(arr);
        return NULL;
    }
    
    arr->size = 0;
    arr->capacity = initial_capacity;
    arr->total_allocated = initial_capacity * sizeof(int);
    
    global_memory_used += sizeof(DynamicArray) + arr->total_allocated;
    global_allocations++;
    
    return arr;
}

EMSCRIPTEN_KEEPALIVE
void destroy_array(DynamicArray* arr) {
    if (arr) {
        global_memory_used -= sizeof(DynamicArray) + arr->total_allocated;
        global_deallocations++;
        
        free(arr->data);
        free(arr);
    }
}

static int resize_array(DynamicArray* arr, size_t new_capacity) {
    if (new_capacity == 0) new_capacity = 1;
    
    int* new_data = realloc(arr->data, new_capacity * sizeof(int));
    if (!new_data) return 0; // 分配失败
    
    // 更新内存统计
    size_t old_size = arr->total_allocated;
    size_t new_size = new_capacity * sizeof(int);
    global_memory_used = global_memory_used - old_size + new_size;
    
    arr->data = new_data;
    arr->capacity = new_capacity;
    arr->total_allocated = new_size;
    
    if (arr->size > new_capacity) {
        arr->size = new_capacity;
    }
    
    return 1; // 成功
}

EMSCRIPTEN_KEEPALIVE
int push_back(DynamicArray* arr, int value) {
    if (!arr) return 0;
    
    if (arr->size >= arr->capacity) {
        size_t new_capacity = arr->capacity * 2;
        if (!resize_array(arr, new_capacity)) {
            return 0; // 扩容失败
        }
    }
    
    arr->data[arr->size++] = value;
    return 1;
}

EMSCRIPTEN_KEEPALIVE
int pop_back(DynamicArray* arr) {
    if (!arr || arr->size == 0) return 0;
    
    arr->size--;
    
    // 如果使用率低于25%，缩减容量
    if (arr->size > 0 && arr->size <= arr->capacity / 4) {
        resize_array(arr, arr->capacity / 2);
    }
    
    return 1;
}

EMSCRIPTEN_KEEPALIVE
int get_element(DynamicArray* arr, size_t index) {
    if (!arr || index >= arr->size) return -1;
    return arr->data[index];
}

EMSCRIPTEN_KEEPALIVE
int set_element(DynamicArray* arr, size_t index, int value) {
    if (!arr || index >= arr->size) return 0;
    arr->data[index] = value;
    return 1;
}

EMSCRIPTEN_KEEPALIVE
size_t get_size(DynamicArray* arr) {
    return arr ? arr->size : 0;
}

EMSCRIPTEN_KEEPALIVE
size_t get_capacity(DynamicArray* arr) {
    return arr ? arr->capacity : 0;
}

EMSCRIPTEN_KEEPALIVE
void shrink_to_fit(DynamicArray* arr) {
    if (arr && arr->size < arr->capacity) {
        resize_array(arr, arr->size);
    }
}

EMSCRIPTEN_KEEPALIVE
void clear_array(DynamicArray* arr) {
    if (arr) {
        arr->size = 0;
        // 可选：重置为初始容量
        resize_array(arr, 1);
    }
}

// 内存统计函数
EMSCRIPTEN_KEEPALIVE
size_t get_global_memory_used() {
    return global_memory_used;
}

EMSCRIPTEN_KEEPALIVE
size_t get_global_allocations() {
    return global_allocations;
}

EMSCRIPTEN_KEEPALIVE
size_t get_global_deallocations() {
    return global_deallocations;
}

EMSCRIPTEN_KEEPALIVE
void print_memory_stats() {
    printf("内存统计:\n");
    printf("  当前使用: %zu 字节\n", global_memory_used);
    printf("  总分配次数: %zu\n", global_allocations);
    printf("  总释放次数: %zu\n", global_deallocations);
    printf("  未释放对象: %zu\n", global_allocations - global_deallocations);
}

// 批量操作
EMSCRIPTEN_KEEPALIVE
void fill_array(DynamicArray* arr, int value, size_t count) {
    if (!arr) return;
    
    // 确保有足够空间
    while (arr->capacity < count) {
        if (!resize_array(arr, arr->capacity * 2)) {
            return; // 扩容失败
        }
    }
    
    for (size_t i = 0; i < count; i++) {
        arr->data[i] = value;
    }
    arr->size = count;
}

EMSCRIPTEN_KEEPALIVE
int* get_data_pointer(DynamicArray* arr) {
    return arr ? arr->data : NULL;
}

2. 编译脚本:

emcc dynamic_array.c -o dynamic_array.js \
  -s EXPORTED_FUNCTIONS='["_create_array","_destroy_array","_push_back","_pop_back","_get_element","_set_element","_get_size","_get_capacity","_shrink_to_fit","_clear_array","_get_global_memory_used","_get_global_allocations","_get_global_deallocations","_print_memory_stats","_fill_array","_get_data_pointer"]' \
  -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap"]' \
  -s ALLOW_MEMORY_GROWTH=1 \
  -O2

3. JavaScript 包装器:

class WasmDynamicArray {
    constructor(module, initialCapacity = 10) {
        this.Module = module;
        this.ptr = module.ccall('create_array', 'number', ['number'], [initialCapacity]);
        
        if (this.ptr === 0) {
            throw new Error('Failed to allocate dynamic array');
        }
        
        // 包装函数
        this.pushBack = module.cwrap('push_back', 'number', ['number', 'number']);
        this.popBack = module.cwrap('pop_back', 'number', ['number']);
        this.getElement = module.cwrap('get_element', 'number', ['number', 'number']);
        this.setElement = module.cwrap('set_element', 'number', ['number', 'number', 'number']);
        this.getSize = module.cwrap('get_size', 'number', ['number']);
        this.getCapacity = module.cwrap('get_capacity', 'number', ['number']);
        this.shrinkToFit = module.cwrap('shrink_to_fit', null, ['number']);
        this.clear = module.cwrap('clear_array', null, ['number']);
        this.fillArray = module.cwrap('fill_array', null, ['number', 'number', 'number']);
        this.getDataPointer = module.cwrap('get_data_pointer', 'number', ['number']);
    }
    
    destructor() {
        if (this.ptr) {
            this.Module.ccall('destroy_array', null, ['number'], [this.ptr]);
            this.ptr = 0;
        }
    }
    
    push(value) {
        const result = this.pushBack(this.ptr, value);
        if (!result) {
            throw new Error('Failed to push element - memory allocation failed');
        }
        return this;
    }
    
    pop() {
        const result = this.popBack(this.ptr);
        if (!result) {
            throw new Error('Cannot pop from empty array');
        }
        return this;
    }
    
    get(index) {
        const result = this.getElement(this.ptr, index);
        if (result === -1) {
            throw new Error('Index out of bounds');
        }
        return result;
    }
    
    set(index, value) {
        const result = this.setElement(this.ptr, index, value);
        if (!result) {
            throw new Error('Index out of bounds');
        }
        return this;
    }
    
    get size() {
        return this.getSize(this.ptr);
    }
    
    get capacity() {
        return this.getCapacity(this.ptr);
    }
    
    shrink() {
        this.shrinkToFit(this.ptr);
        return this;
    }
    
    fill(value, count) {
        this.fillArray(this.ptr, value, count);
        return this;
    }
    
    toArray() {
        const size = this.size;
        const result = [];
        for (let i = 0; i < size; i++) {
            result.push(this.get(i));
        }
        return result;
    }
    
    // 直接访问底层内存（高性能操作）
    getDirectAccess() {
        const dataPtr = this.getDataPointer(this.ptr);
        const size = this.size;
        return new Int32Array(this.Module.HEAP32.buffer, dataPtr, size);
    }
    
    static getMemoryStats(module) {
        return {
            used: module.ccall('get_global_memory_used', 'number', []),
            allocations: module.ccall('get_global_allocations', 'number', []),
            deallocations: module.ccall('get_global_deallocations', 'number', [])
        };
    }
    
    static printMemoryStats(module) {
        module.ccall('print_memory_stats', null, []);
    }
}

// 使用示例和测试
Module.onRuntimeInitialized = function() {
    console.log('动态数组测试开始...');
    
    try {
        // 创建数组
        const arr = new WasmDynamicArray(Module, 5);
        console.log('初始容量:', arr.capacity); // 5
        
        // 添加元素
        for (let i = 0; i < 10; i++) {
            arr.push(i * i);
        }
        console.log('添加10个元素后:');
        console.log('  大小:', arr.size);     // 10
        console.log('  容量:', arr.capacity); // 应该是8或更大
        console.log('  内容:', arr.toArray());
        
        // 内存统计
        console.log('内存统计:', WasmDynamicArray.getMemoryStats(Module));
        
        // 修改元素
        arr.set(5, 999);
        console.log('修改索引5后:', arr.get(5)); // 999
        
        // 弹出元素
        arr.pop().pop().pop();
        console.log('弹出3个元素后大小:', arr.size); // 7
        
        // 收缩内存
        arr.shrink();
        console.log('收缩后容量:', arr.capacity);
        
        // 批量填充
        arr.fill(42, 15);
        console.log('批量填充后:', arr.size, arr.capacity);
        
        // 直接内存访问（高性能）
        const directAccess = arr.getDirectAccess();
        console.log('直接访问前5个元素:', Array.from(directAccess.slice(0, 5)));
        
        // 修改直接访问的数据
        directAccess[0] = 1000;
        console.log('直接修改后第一个元素:', arr.get(0)); // 1000
        
        // 清理
        arr.destructor();
        
        // 最终内存统计
        console.log('最终内存统计:', WasmDynamicArray.getMemoryStats(Module));
        WasmDynamicArray.printMemoryStats(Module);
        
    } catch (error) {
        console.error('测试错误:', error);
    }
    
    // 内存泄漏测试
    console.log('\n内存泄漏测试...');
    const initialStats = WasmDynamicArray.getMemoryStats(Module);
    
    // 创建并销毁多个数组
    for (let i = 0; i < 100; i++) {
        const tempArr = new WasmDynamicArray(Module, 10);
        tempArr.fill(i, 20);
        tempArr.destructor();
    }
    
    const finalStats = WasmDynamicArray.getMemoryStats(Module);
    console.log('内存泄漏测试结果:');
    console.log('  分配次数差:', finalStats.allocations - initialStats.allocations);
    console.log('  释放次数差:', finalStats.deallocations - initialStats.deallocations);
    console.log('  内存使用差:', finalStats.used - initialStats.used);
    
    if (finalStats.allocations === finalStats.deallocations) {
        console.log('✅ 无内存泄漏');
    } else {
        console.log('❌ 检测到内存泄漏');
    }
};

预期结果:

• 动态数组能正确扩容和缩容
• 内存统计准确跟踪分配和释放
• 无内存泄漏
• 支持高性能的直接内存访问

1. 内存池实现 (memory_pool.c):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <emscripten.h>

#define MAX_POOLS 8
#define POOL_BLOCK_COUNT 256

typedef struct Block {
    struct Block* next;
} Block;

typedef struct {
    size_t block_size;
    size_t total_blocks;
    size_t free_blocks;
    Block* free_list;
    void* memory_start;
    size_t total_memory;
} MemoryPool;

typedef struct {
    MemoryPool pools[MAX_POOLS];
    size_t pool_count;
    size_t total_allocated;
    size_t total_free_calls;
    size_t total_alloc_calls;
} PoolManager;

static PoolManager g_manager = {0};

// 内部函数
static MemoryPool* find_suitable_pool(size_t size) {
    for (size_t i = 0; i < g_manager.pool_count; i++) {
        if (g_manager.pools[i].block_size >= size) {
            return &g_manager.pools[i];
        }
    }
    return NULL;
}

static void init_pool(MemoryPool* pool, size_t block_size, size_t block_count) {
    pool->block_size = block_size;
    pool->total_blocks = block_count;
    pool->free_blocks = block_count;
    pool->total_memory = block_size * block_count;
    
    // 分配连续内存
    pool->memory_start = malloc(pool->total_memory);
    if (!pool->memory_start) {
        pool->free_blocks = 0;
        return;
    }
    
    // 初始化空闲链表
    pool->free_list = (Block*)pool->memory_start;
    Block* current = pool->free_list;
    
    for (size_t i = 0; i < block_count - 1; i++) {
        current->next = (Block*)((char*)current + block_size);
        current = current->next;
    }
    current->next = NULL;
}

EMSCRIPTEN_KEEPALIVE
int init_memory_pools() {
    if (g_manager.pool_count > 0) {
        return 1; // 已初始化
    }
    
    // 定义不同大小的内存池
    size_t sizes[] = {16, 32, 64, 128, 256, 512, 1024, 2048};
    
    g_manager.pool_count = sizeof(sizes) / sizeof(sizes[0]);
    
    for (size_t i = 0; i < g_manager.pool_count; i++) {
        init_pool(&g_manager.pools[i], sizes[i], POOL_BLOCK_COUNT);
        if (!g_manager.pools[i].memory_start) {
            // 初始化失败，清理已分配的池
            for (size_t j = 0; j < i; j++) {
                free(g_manager.pools[j].memory_start);
            }
            g_manager.pool_count = 0;
            return 0;
        }
    }
    
    return 1;
}

EMSCRIPTEN_KEEPALIVE
void destroy_memory_pools() {
    for (size_t i = 0; i < g_manager.pool_count; i++) {
        free(g_manager.pools[i].memory_start);
    }
    memset(&g_manager, 0, sizeof(g_manager));
}

EMSCRIPTEN_KEEPALIVE
void* pool_alloc(size_t size) {
    if (g_manager.pool_count == 0) {
        if (!init_memory_pools()) {
            return NULL;
        }
    }
    
    g_manager.total_alloc_calls++;
    
    MemoryPool* pool = find_suitable_pool(size);
    if (!pool || pool->free_blocks == 0) {
        // 回退到标准 malloc
        return malloc(size);
    }
    
    // 从空闲链表中取出一块
    Block* block = pool->free_list;
    pool->free_list = block->next;
    pool->free_blocks--;
    
    g_manager.total_allocated += pool->block_size;
    
    return block;
}

EMSCRIPTEN_KEEPALIVE
void pool_free(void* ptr, size_t size) {
    if (!ptr) return;
    
    g_manager.total_free_calls++;
    
    MemoryPool* pool = find_suitable_pool(size);
    if (!pool) {
        // 回退到标准 free
        free(ptr);
        return;
    }
    
    // 检查指针是否属于这个池
    char* start = (char*)pool->memory_start;
    char* end = start + pool->total_memory;
    char* p = (char*)ptr;
    
    if (p < start || p >= end) {
        // 不属于池，使用标准 free
        free(ptr);
        return;
    }
    
    // 将块添加回空闲链表
    Block* block = (Block*)ptr;
    block->next = pool->free_list;
    pool->free_list = block;
    pool->free_blocks++;
    
    g_manager.total_allocated -= pool->block_size;
}

// 统计函数
EMSCRIPTEN_KEEPALIVE
size_t get_pool_count() {
    return g_manager.pool_count;
}

EMSCRIPTEN_KEEPALIVE
size_t get_pool_block_size(size_t pool_index) {
    if (pool_index >= g_manager.pool_count) return 0;
    return g_manager.pools[pool_index].block_size;
}

EMSCRIPTEN_KEEPALIVE
size_t get_pool_total_blocks(size_t pool_index) {
    if (pool_index >= g_manager.pool_count) return 0;
    return g_manager.pools[pool_index].total_blocks;
}

EMSCRIPTEN_KEEPALIVE
size_t get_pool_free_blocks(size_t pool_index) {
    if (pool_index >= g_manager.pool_count) return 0;
    return g_manager.pools[pool_index].free_blocks;
}

EMSCRIPTEN_KEEPALIVE
size_t get_pool_used_blocks(size_t pool_index) {
    if (pool_index >= g_manager.pool_count) return 0;
    MemoryPool* pool = &g_manager.pools[pool_index];
    return pool->total_blocks - pool->free_blocks;
}

EMSCRIPTEN_KEEPALIVE
double get_pool_utilization(size_t pool_index) {
    if (pool_index >= g_manager.pool_count) return 0.0;
    MemoryPool* pool = &g_manager.pools[pool_index];
    if (pool->total_blocks == 0) return 0.0;
    return (double)(pool->total_blocks - pool->free_blocks) / pool->total_blocks;
}

EMSCRIPTEN_KEEPALIVE
size_t get_total_allocated() {
    return g_manager.total_allocated;
}

EMSCRIPTEN_KEEPALIVE
size_t get_total_alloc_calls() {
    return g_manager.total_alloc_calls;
}

EMSCRIPTEN_KEEPALIVE
size_t get_total_free_calls() {
    return g_manager.total_free_calls;
}

EMSCRIPTEN_KEEPALIVE
void print_pool_stats() {
    printf("\n=== 内存池统计 ===\n");
    printf("池数量: %zu\n", g_manager.pool_count);
    printf("总分配调用: %zu\n", g_manager.total_alloc_calls);
    printf("总释放调用: %zu\n", g_manager.total_free_calls);
    printf("当前已分配: %zu 字节\n", g_manager.total_allocated);
    
    printf("\n各池详情:\n");
    printf("块大小\t总块数\t已用\t空闲\t利用率\n");
    printf("--------------------------------\n");
    
    for (size_t i = 0; i < g_manager.pool_count; i++) {
        MemoryPool* pool = &g_manager.pools[i];
        size_t used = pool->total_blocks - pool->free_blocks;
        double util = (double)used / pool->total_blocks * 100.0;
        
        printf("%zu\t%zu\t%zu\t%zu\t%.1f%%\n",
               pool->block_size, pool->total_blocks, 
               used, pool->free_blocks, util);
    }
}

// 性能测试函数
EMSCRIPTEN_KEEPALIVE
double benchmark_pool_allocation(size_t size, size_t iterations) {
    double start = emscripten_get_now();
    
    void** ptrs = malloc(iterations * sizeof(void*));
    
    // 分配
    for (size_t i = 0; i < iterations; i++) {
        ptrs[i] = pool_alloc(size);
    }
    
    // 释放
    for (size_t i = 0; i < iterations; i++) {
        pool_free(ptrs[i], size);
    }
    
    free(ptrs);
    
    double end = emscripten_get_now();
    return end - start;
}

EMSCRIPTEN_KEEPALIVE
double benchmark_standard_allocation(size_t size, size_t iterations) {
    double start = emscripten_get_now();
    
    void** ptrs = malloc(iterations * sizeof(void*));
    
    // 分配
    for (size_t i = 0; i < iterations; i++) {
        ptrs[i] = malloc(size);
    }
    
    // 释放
    for (size_t i = 0; i < iterations; i++) {
        free(ptrs[i]);
    }
    
    free(ptrs);
    
    double end = emscripten_get_now();
    return end - start;
}

2. JavaScript 包装器:

class WasmMemoryPool {
    constructor(module) {
        this.Module = module;
        
        // 初始化内存池
        const initResult = module.ccall('init_memory_pools', 'number', []);
        if (!initResult) {
            throw new Error('Failed to initialize memory pools');
        }
        
        // 包装函数
        this.poolAlloc = module.cwrap('pool_alloc', 'number', ['number']);
        this.poolFree = module.cwrap('pool_free', null, ['number', 'number']);
        this.benchmarkPool = module.cwrap('benchmark_pool_allocation', 'number', ['number', 'number']);
        this.benchmarkStandard = module.cwrap('benchmark_standard_allocation', 'number', ['number', 'number']);
        
        this.allocatedBlocks = new Map(); // 跟踪分配的块
    }
    
    alloc(size) {
        const ptr = this.poolAlloc(size);
        if (ptr === 0) {
            throw new Error(`Failed to allocate ${size} bytes`);
        }
        this.allocatedBlocks.set(ptr, size);
        return ptr;
    }
    
    free(ptr) {
        if (this.allocatedBlocks.has(ptr)) {
            const size = this.allocatedBlocks.get(ptr);
            this.poolFree(ptr, size);
            this.allocatedBlocks.delete(ptr);
        }
    }
    
    getStats() {
        const poolCount = this.Module.ccall('get_pool_count', 'number', []);
        const stats = {
            totalAllocCalls: this.Module.ccall('get_total_alloc_calls', 'number', []),
            totalFreeCalls: this.Module.ccall('get_total_free_calls', 'number', []),
            totalAllocated: this.Module.ccall('get_total_allocated', 'number', []),
            pools: []
        };
        
        for (let i = 0; i < poolCount; i++) {
            stats.pools.push({
                blockSize: this.Module.ccall('get_pool_block_size', 'number', ['number'], [i]),
                totalBlocks: this.Module.ccall('get_pool_total_blocks', 'number', ['number'], [i]),
                freeBlocks: this.Module.ccall('get_pool_free_blocks', 'number', ['number'], [i]),
                usedBlocks: this.Module.ccall('get_pool_used_blocks', 'number', ['number'], [i]),
                utilization: this.Module.ccall('get_pool_utilization', 'number', ['number'], [i])
            });
        }
        
        return stats;
    }
    
    printStats() {
        this.Module.ccall('print_pool_stats', null, []);
    }
    
    benchmark(size, iterations) {
        const poolTime = this.benchmarkPool(size, iterations);
        const standardTime = this.benchmarkStandard(size, iterations);
        
        return {
            poolTime,
            standardTime,
            speedup: standardTime / poolTime,
            iterations,
            size
        };
    }
    
    destroy() {
        // 释放所有未释放的块
        for (const [ptr, size] of this.allocatedBlocks) {
            this.poolFree(ptr, size);
        }
        this.allocatedBlocks.clear();
        
        this.Module.ccall('destroy_memory_pools', null, []);
    }
}

// 测试和演示
Module.onRuntimeInitialized = function() {
    console.log('内存池测试开始...');
    
    try {
        const pool = new WasmMemoryPool(Module);
        
        // 基本分配测试
        console.log('\n=== 基本分配测试 ===');
        const ptrs = [];
        const sizes = [16, 32, 64, 128, 256];
        
        // 分配不同大小的块
        for (let size of sizes) {
            for (let i = 0; i < 10; i++) {
                const ptr = pool.alloc(size);
                ptrs.push(ptr);
            }
        }
        
        console.log('分配50个块后的统计:');
        pool.printStats();
        
        // 释放一半的块
        for (let i = 0; i < ptrs.length / 2; i++) {
            pool.free(ptrs[i]);
        }
        
        console.log('\n释放25个块后的统计:');
        pool.printStats();
        
        // 性能基准测试
        console.log('\n=== 性能基准测试 ===');
        const testSizes = [32, 128, 512];
        const iterations = 10000;
        
        for (let size of testSizes) {
            const result = pool.benchmark(size, iterations);
            console.log(`大小 ${size} 字节, ${iterations} 次迭代:`);
            console.log(`  内存池: ${result.poolTime.toFixed(2)} ms`);
            console.log(`  标准malloc: ${result.standardTime.toFixed(2)} ms`);
            console.log(`  加速比: ${result.speedup.toFixed(2)}x`);
        }
        
        // 碎片分析测试
        console.log('\n=== 碎片分析测试 ===');
        const fragmentationPtrs = [];
        
        // 分配大量小块
        for (let i = 0; i < 100; i++) {
            fragmentationPtrs.push(pool.alloc(32));
        }
        
        // 释放一些块造成碎片
        for (let i = 0; i < fragmentationPtrs.length; i += 3) {
            pool.free(fragmentationPtrs[i]);
        }
        
        console.log('碎片化后的统计:');
        const stats = pool.getStats();
        console.log('32字节池利用率:', (stats.pools[1].utilization * 100).toFixed(1) + '%');
        
        // 清理剩余的块
        for (let i = 1; i < fragmentationPtrs.length; i += 3) {
            if (i < fragmentationPtrs.length) pool.free(fragmentationPtrs[i]);
            if (i + 1 < fragmentationPtrs.length) pool.free(fragmentationPtrs[i + 1]);
        }
        
        // 清理剩余的测试块
        for (let i = Math.floor(ptrs.length / 2); i < ptrs.length; i++) {
            pool.free(ptrs[i]);
        }
        
        console.log('\n=== 最终统计 ===');
        pool.printStats();
        
        // 销毁内存池
        pool.destroy();
        console.log('\n内存池已销毁');
        
    } catch (error) {
        console.error('测试错误:', error);
    }
};

预期结果:

• 内存池能显著提高小块分配的性能（2-5倍加速）
• 减少内存碎片
• 提供详细的使用统计
• 支持不同大小的块分配

实现将在下一个练习中继续…

由于内容较长，我将继续实现剩余的练习内容。这个练习展示了内存池的完整实现，包括多种大小的池、性能基准测试和碎片分析。