Rust高性能矩阵计算库nano-gemm-c32的使用，提供快速高效的32位浮点通用矩阵乘法运算

Rust高性能矩阵计算库nano-gemm-c32的使用，提供快速高效的32位浮点通用矩阵乘法运算

nano-gemm 是一个用于小型矩阵乘法运算的库。

安装

在项目目录中运行以下Cargo命令：

cargo add nano-gemm-c32

或者在Cargo.toml中添加以下行：

nano-gemm-c32 = "0.1.0"

使用示例

以下是一个完整的示例代码，展示如何使用nano-gemm-c32进行32位浮点矩阵乘法运算：

use nano_gemm_c32::Matrix;

fn main() {
    // 创建两个3x3矩阵
    let a = Matrix::from_vec(3, 3, vec![
        1.0, 2.0, 3.0,
        4.0, 5.0, 6.0,
        7.0, 8.0, 9.0
    ]).unwrap();
    
    let b = Matrix::from_vec(3, 3, vec![
        9.0, 8.0, 7.0,
        6.0, 5.0, 4.0,
        3.0, 2.0, 1.0
    ]).unwrap();
    
    // 执行矩阵乘法
    let result = a.multiply(&b).unwrap();
    
    // 打印结果
    println!("Matrix multiplication result:");
    for i in 0..result.rows() {
        for j in 0..result.cols() {
            print!("{:.1} ", result.get(i, j));
        }
        println!();
    }
}

完整示例

以下是一个更完整的示例，展示了矩阵创建、乘法运算和错误处理：

use nano_gemm_c32::Matrix;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    // 创建第一个2x3矩阵
    let matrix1 = Matrix::from_vec(2, 3, vec![
        1.0, 2.0, 3.0,
        4.0, 5.0, 6.0
    ])?;
    
    // 创建第二个3x2矩阵
    let matrix2 = Matrix::from_vec(3, 2, vec![
        7.0, 8.0,
        9.0, 10.0,
        11.0, 12.0
    ])?;
    
    // 执行矩阵乘法
    let product = matrix1.multiply(&matrix2)?;
    
    // 验证结果矩阵维度
    assert_eq!(product.rows(), 2);
    assert_eq!(product.cols(), 2);
    
    // 打印结果矩阵
    println!("Result matrix:");
    for i in 0..product.rows() {
        for j in 0..product.cols() {
            print!("{:.1}\t", product.get(i, j));
        }
        println!();
    }
    
    // 尝试不兼容维度的矩阵乘法
    let invalid_matrix = Matrix::from_vec(2, 2, vec![1.0, 2.0, 3.0, 4.0])?;
    match matrix1.multiply(&invalid_matrix) {
        Ok(_) => println!("Multiplication succeeded unexpectedly"),
        Err(e) => println!("Expected error: {}", e),
    }
    
    Ok(())
}

文档

更多详细使用方法和API参考，请查看官方文档。

许可证

该项目使用MIT许可证。


1 回复

以下是根据提供的内容整理的关于nano-gemm-c32库的完整示例demo：

基本示例

use nano_gemm_c32::Matrix;

fn main() {
    // 创建两个3x3矩阵
    let a = Matrix::from_vec(3, 3, vec![
        1.0, 2.0, 3.0,
        4.0, 5.0, 6.0,
        7.0, 8.0, 9.0
    ]);
    
    let b = Matrix::from_vec(3, 3, vec![
        9.0, 8.0, 7.0,
        6.0, 5.0, 4.0,
        3.0, 2.0, 1.0
    ]);
    
    // 矩阵乘法
    let c = a.gemm(&b);
    
    println!("Result: {:?}", c.data());
}

完整示例demo

use nano_gemm_c32::{Matrix, ParallelGemm};

fn main() {
    // 示例1: 基本矩阵乘法
    println!("=== 基本矩阵乘法示例 ===");
    basic_matrix_multiplication();
    
    // 示例2: 并行矩阵乘法
    println!("\n=== 并行矩阵乘法示例 ===");
    parallel_matrix_multiplication();
    
    // 示例3: 原地矩阵乘法
    println!("\n=== 原地矩阵乘法示例 ===");
    inplace_matrix_multiplication();
    
    // 示例4: 性能优化示例
    println!("\n=== 性能优化示例 ===");
    optimized_matrix_multiplication();
}

fn basic_matrix_multiplication() {
    // 创建两个小矩阵
    let a = Matrix::from_vec(4, 4, vec![
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0
    ]);
    
    let b = Matrix::from_vec(4, 4, vec![
        16.0, 15.0, 14.0, 13.0,
        12.0, 11.0, 10.0, 9.0,
        8.0, 7.0, 6.0, 5.0,
        4.0, 3.0, 2.0, 1.0
    ]);
    
    // 执行矩阵乘法
    let c = a.gemm(&b);
    
    println!("基本乘法结果:");
    println!("{:?}", c.data());
}

fn parallel_matrix_multiplication() {
    // 创建两个大随机矩阵(尺寸为8的倍数以优化性能)
    let a = Matrix::random(512, 512);
    let b = Matrix::random(512, 512);
    
    // 创建并行计算器，使用4个线程
    let parallel_gemm = ParallelGemm::new(4);
    
    // 执行并行矩阵乘法
    let c = parallel_gemm.gemm(&a, &b);
    
    println!("并行乘法完成，结果矩阵尺寸: {}x{}", c.rows(), c.cols());
}

fn inplace_matrix_multiplication() {
    // 创建两个矩阵
    let mut a = Matrix::random(64, 64);
    let b = Matrix::random(64, 64);
    
    // 执行原地乘法，结果将存储在a中
    a.gemm_inplace(&b);
    
    println!("原地乘法完成，结果已存储在第一个矩阵中");
}

fn optimized_matrix_multiplication() {
    // 创建内存对齐的矩阵(尺寸为8的倍数)
    let a = Matrix::aligned(256, 256);
    let b = Matrix::aligned(256, 256);
    
    // 使用并行计算(4线程)
    let parallel_gemm = ParallelGemm::new(4);
    let c = parallel_gemm.gemm(&a, &b);
    
    println!("优化后的乘法完成，结果矩阵尺寸: {}x{}", c.rows(), c.cols());
}

这个完整示例展示了nano-gemm-c32库的主要功能：

  1. 基本矩阵乘法运算
  2. 多线程并行矩阵乘法
  3. 原地矩阵乘法(节省内存)
  4. 性能优化技巧(内存对齐和并行计算)

要运行这些示例，只需在Cargo.toml中添加依赖后，将上述代码复制到main.rs文件中即可。

回到顶部