397 lines
13 KiB
Rust
397 lines
13 KiB
Rust
|
use std::time::Instant;
|
||
|
|
|
||
|
|
use anyhow::Result;
|
||
|
|
use image::{ImageReader, Rgba, RgbaImage};
|
||
|
|
use rayon::prelude::*;
|
||
|
|
|
||
|
|
/// 测试像素组合性能对比
|
||
|
|
#[test]
|
||
|
|
fn test_pixel_combine_performance() -> Result<()> {
|
||
|
|
// cargo test test_pixel_combine_performance -r -- --nocapture
|
||
|
|
let img_path = "./assets/img/gougou.jpg";
|
||
|
|
let img = ImageReader::open(img_path)?.decode()?;
|
||
|
|
// 缩小图片以加快测试
|
||
|
|
let img = img.resize(1024, 1024, image::imageops::FilterType::Nearest);
|
||
|
|
let width = img.width();
|
||
|
|
let height = img.height();
|
||
|
|
let rgb_img = img.to_rgb8();
|
||
|
|
|
||
|
|
// 模拟 alpha 通道
|
||
|
|
let alpha_gray = image::GrayImage::from_fn(width, height, |x, y| {
|
||
|
|
image::Luma([((x + y) % 256) as u8])
|
||
|
|
});
|
||
|
|
|
||
|
|
let iterations = 50;
|
||
|
|
|
||
|
|
println!("=== 像素组合性能测试 ===");
|
||
|
|
println!("图片尺寸: {}x{}", width, height);
|
||
|
|
println!();
|
||
|
|
|
||
|
|
// 旧方法：逐像素操作
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let mut rgba_img = RgbaImage::new(width, height);
|
||
|
|
for (x, y, pixel) in rgb_img.enumerate_pixels() {
|
||
|
|
let alpha_value = alpha_gray.get_pixel(x, y).0[0];
|
||
|
|
let rgba_pixel = Rgba([pixel.0[0], pixel.0[1], pixel.0[2], alpha_value]);
|
||
|
|
rgba_img.put_pixel(x, y, rgba_pixel);
|
||
|
|
}
|
||
|
|
std::hint::black_box(&rgba_img);
|
||
|
|
}
|
||
|
|
let old_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"旧方法（逐像素）: {:?}, 平均: {:?}",
|
||
|
|
old_duration,
|
||
|
|
old_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
// 新方法：串行索引赋值
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let rgb_raw = rgb_img.as_raw();
|
||
|
|
let alpha_raw = alpha_gray.as_raw();
|
||
|
|
let pixel_count = (width * height) as usize;
|
||
|
|
let mut rgba_raw = vec![0u8; pixel_count * 4];
|
||
|
|
|
||
|
|
for i in 0..pixel_count {
|
||
|
|
let dst = i * 4;
|
||
|
|
let src = i * 3;
|
||
|
|
rgba_raw[dst] = rgb_raw[src];
|
||
|
|
rgba_raw[dst + 1] = rgb_raw[src + 1];
|
||
|
|
rgba_raw[dst + 2] = rgb_raw[src + 2];
|
||
|
|
rgba_raw[dst + 3] = alpha_raw[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
let rgba_img = RgbaImage::from_raw(width, height, rgba_raw).unwrap();
|
||
|
|
std::hint::black_box(&rgba_img);
|
||
|
|
}
|
||
|
|
let serial_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"新方法（串行索引）: {:?}, 平均: {:?}",
|
||
|
|
serial_duration,
|
||
|
|
serial_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
// 新方法：并行分块写入
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let rgb_raw = rgb_img.as_raw();
|
||
|
|
let alpha_raw = alpha_gray.as_raw();
|
||
|
|
let pixel_count = (width * height) as usize;
|
||
|
|
let mut rgba_raw = vec![0u8; pixel_count * 4];
|
||
|
|
|
||
|
|
rgba_raw
|
||
|
|
.par_chunks_mut(4)
|
||
|
|
.enumerate()
|
||
|
|
.for_each(|(i, chunk)| {
|
||
|
|
let src = i * 3;
|
||
|
|
chunk[0] = rgb_raw[src];
|
||
|
|
chunk[1] = rgb_raw[src + 1];
|
||
|
|
chunk[2] = rgb_raw[src + 2];
|
||
|
|
chunk[3] = alpha_raw[i];
|
||
|
|
});
|
||
|
|
|
||
|
|
let rgba_img = RgbaImage::from_raw(width, height, rgba_raw).unwrap();
|
||
|
|
std::hint::black_box(&rgba_img);
|
||
|
|
}
|
||
|
|
let parallel_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"新方法（并行）: {:?}, 平均: {:?}",
|
||
|
|
parallel_duration,
|
||
|
|
parallel_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
let speedup_serial = old_duration.as_secs_f64() / serial_duration.as_secs_f64();
|
||
|
|
let speedup_parallel = old_duration.as_secs_f64() / parallel_duration.as_secs_f64();
|
||
|
|
println!();
|
||
|
|
println!("串行索引 vs 逐像素: {:.2}x", speedup_serial);
|
||
|
|
println!("并行 vs 逐像素: {:.2}x", speedup_parallel);
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// 测试图片 resize 性能对比（串行 vs 并行）
|
||
|
|
#[test]
|
||
|
|
fn test_image_resize_parallel_vs_serial() -> Result<()> {
|
||
|
|
// cargo test test_image_resize_parallel_vs_serial -r -- --nocapture
|
||
|
|
let img_path = "./assets/img/gougou.jpg";
|
||
|
|
let img = ImageReader::open(img_path)?.decode()?;
|
||
|
|
// 缩小原图以加快测试
|
||
|
|
let img = img.resize(2048, 2048, image::imageops::FilterType::Nearest);
|
||
|
|
|
||
|
|
let num_images = 4;
|
||
|
|
let imgs: Vec<_> = (0..num_images).map(|_| img.clone()).collect();
|
||
|
|
let target_h = 1024u32;
|
||
|
|
let target_w = 1024u32;
|
||
|
|
|
||
|
|
let iterations = 10;
|
||
|
|
|
||
|
|
println!("=== 图片 Resize 性能测试 ===");
|
||
|
|
println!("图片数量: {}", num_images);
|
||
|
|
println!("原始尺寸: {}x{}", img.width(), img.height());
|
||
|
|
println!("目标尺寸: {}x{}", target_w, target_h);
|
||
|
|
println!();
|
||
|
|
|
||
|
|
// 串行 resize
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let mut results = Vec::with_capacity(num_images);
|
||
|
|
for img in &imgs {
|
||
|
|
let resized =
|
||
|
|
img.resize_exact(target_w, target_h, image::imageops::FilterType::CatmullRom);
|
||
|
|
results.push(resized);
|
||
|
|
}
|
||
|
|
std::hint::black_box(&results);
|
||
|
|
}
|
||
|
|
let serial_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"串行 resize: {:?}, 平均: {:?}",
|
||
|
|
serial_duration,
|
||
|
|
serial_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
// 并行 resize
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let results: Vec<_> = imgs
|
||
|
|
.par_iter()
|
||
|
|
.map(|img| {
|
||
|
|
img.resize_exact(target_w, target_h, image::imageops::FilterType::CatmullRom)
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
std::hint::black_box(&results);
|
||
|
|
}
|
||
|
|
let parallel_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"并行 resize: {:?}, 平均: {:?}",
|
||
|
|
parallel_duration,
|
||
|
|
parallel_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
let speedup = serial_duration.as_secs_f64() / parallel_duration.as_secs_f64();
|
||
|
|
println!();
|
||
|
|
println!("并行 vs 串行: {:.2}x", speedup);
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// 测试后处理阶段并行 vs 串行性能（纯图像操作）
|
||
|
|
#[test]
|
||
|
|
fn test_postprocess_parallel_vs_serial() -> Result<()> {
|
||
|
|
// cargo test test_postprocess_parallel_vs_serial -r -- --nocapture
|
||
|
|
let img_path = "./assets/img/gougou.jpg";
|
||
|
|
let img = ImageReader::open(img_path)?.decode()?;
|
||
|
|
// 缩小图片以加快测试
|
||
|
|
let img = img.resize(1024, 1024, image::imageops::FilterType::Nearest);
|
||
|
|
let width = img.width();
|
||
|
|
let height = img.height();
|
||
|
|
|
||
|
|
// 模拟多张图片的后处理数据
|
||
|
|
let num_images = 4;
|
||
|
|
let rgb_imgs: Vec<_> = (0..num_images).map(|_| img.to_rgb8()).collect();
|
||
|
|
let alpha_grays: Vec<_> = (0..num_images)
|
||
|
|
.map(|_| {
|
||
|
|
image::GrayImage::from_fn(width, height, |x, y| image::Luma([((x + y) % 256) as u8]))
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
let iterations = 20;
|
||
|
|
|
||
|
|
println!("=== 后处理阶段性能测试（纯图像操作）===");
|
||
|
|
println!("图片数量: {}", num_images);
|
||
|
|
println!("图片尺寸: {}x{}", width, height);
|
||
|
|
println!();
|
||
|
|
|
||
|
|
// 串行后处理（for-in 循环）
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let mut results = Vec::with_capacity(num_images);
|
||
|
|
for i in 0..num_images {
|
||
|
|
let rgb_raw = rgb_imgs[i].as_raw();
|
||
|
|
let alpha_raw = alpha_grays[i].as_raw();
|
||
|
|
let pixel_count = (width * height) as usize;
|
||
|
|
let mut rgba_raw = vec![0u8; pixel_count * 4];
|
||
|
|
|
||
|
|
for j in 0..pixel_count {
|
||
|
|
let dst = j * 4;
|
||
|
|
let src = j * 3;
|
||
|
|
rgba_raw[dst] = rgb_raw[src];
|
||
|
|
rgba_raw[dst + 1] = rgb_raw[src + 1];
|
||
|
|
rgba_raw[dst + 2] = rgb_raw[src + 2];
|
||
|
|
rgba_raw[dst + 3] = alpha_raw[j];
|
||
|
|
}
|
||
|
|
|
||
|
|
let rgba_img = RgbaImage::from_raw(width, height, rgba_raw).unwrap();
|
||
|
|
results.push(rgba_img);
|
||
|
|
}
|
||
|
|
std::hint::black_box(&results);
|
||
|
|
}
|
||
|
|
let serial_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"串行后处理: {:?}, 平均: {:?}",
|
||
|
|
serial_duration,
|
||
|
|
serial_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
// 并行后处理（外层并行 + 内层并行）
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let results: Vec<_> = (0..num_images)
|
||
|
|
.into_par_iter()
|
||
|
|
.map(|i| {
|
||
|
|
let rgb_raw = rgb_imgs[i].as_raw();
|
||
|
|
let alpha_raw = alpha_grays[i].as_raw();
|
||
|
|
let pixel_count = (width * height) as usize;
|
||
|
|
let mut rgba_raw = vec![0u8; pixel_count * 4];
|
||
|
|
|
||
|
|
rgba_raw
|
||
|
|
.par_chunks_mut(4)
|
||
|
|
.enumerate()
|
||
|
|
.for_each(|(j, chunk)| {
|
||
|
|
let src = j * 3;
|
||
|
|
chunk[0] = rgb_raw[src];
|
||
|
|
chunk[1] = rgb_raw[src + 1];
|
||
|
|
chunk[2] = rgb_raw[src + 2];
|
||
|
|
chunk[3] = alpha_raw[j];
|
||
|
|
});
|
||
|
|
|
||
|
|
RgbaImage::from_raw(width, height, rgba_raw).unwrap()
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
std::hint::black_box(&results);
|
||
|
|
}
|
||
|
|
let parallel_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"并行后处理: {:?}, 平均: {:?}",
|
||
|
|
parallel_duration,
|
||
|
|
parallel_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
let speedup = serial_duration.as_secs_f64() / parallel_duration.as_secs_f64();
|
||
|
|
println!();
|
||
|
|
println!("后处理性能提升: {:.2}x", speedup);
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// 测试完整图像处理流程（resize + 像素合并）串行 vs 并行
|
||
|
|
#[test]
|
||
|
|
fn test_full_image_pipeline_parallel_vs_serial() -> Result<()> {
|
||
|
|
// cargo test test_full_image_pipeline_parallel_vs_serial -r -- --nocapture
|
||
|
|
let img_path = "./assets/img/gougou.jpg";
|
||
|
|
let img = ImageReader::open(img_path)?.decode()?;
|
||
|
|
// 缩小图片以加快测试
|
||
|
|
let img = img.resize(2048, 2048, image::imageops::FilterType::Nearest);
|
||
|
|
let orig_width = img.width();
|
||
|
|
let orig_height = img.height();
|
||
|
|
|
||
|
|
let num_images = 4;
|
||
|
|
let imgs: Vec<_> = (0..num_images).map(|_| img.clone()).collect();
|
||
|
|
let target_h = 1024u32;
|
||
|
|
let target_w = 1024u32;
|
||
|
|
|
||
|
|
// 模拟 alpha 蒙版
|
||
|
|
let alpha_grays: Vec<_> = (0..num_images)
|
||
|
|
.map(|_| {
|
||
|
|
image::GrayImage::from_fn(orig_width, orig_height, |x, y| {
|
||
|
|
image::Luma([((x + y) % 256) as u8])
|
||
|
|
})
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
let iterations = 10;
|
||
|
|
|
||
|
|
println!("=== 完整图像处理流程性能测试 ===");
|
||
|
|
println!("图片数量: {}", num_images);
|
||
|
|
println!("原始尺寸: {}x{}", orig_width, orig_height);
|
||
|
|
println!("处理尺寸: {}x{}", target_w, target_h);
|
||
|
|
println!();
|
||
|
|
|
||
|
|
// 串行处理流程
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
let mut results = Vec::with_capacity(num_images);
|
||
|
|
for i in 0..num_images {
|
||
|
|
// 预处理：resize 到模型输入尺寸
|
||
|
|
let _resized =
|
||
|
|
imgs[i].resize_exact(target_w, target_h, image::imageops::FilterType::CatmullRom);
|
||
|
|
|
||
|
|
// 后处理：合并 RGB 和 alpha
|
||
|
|
let rgb_img = imgs[i].to_rgb8();
|
||
|
|
let rgb_raw = rgb_img.as_raw();
|
||
|
|
let alpha_raw = alpha_grays[i].as_raw();
|
||
|
|
let pixel_count = (orig_width * orig_height) as usize;
|
||
|
|
let mut rgba_raw = vec![0u8; pixel_count * 4];
|
||
|
|
|
||
|
|
for j in 0..pixel_count {
|
||
|
|
let dst = j * 4;
|
||
|
|
let src = j * 3;
|
||
|
|
rgba_raw[dst] = rgb_raw[src];
|
||
|
|
rgba_raw[dst + 1] = rgb_raw[src + 1];
|
||
|
|
rgba_raw[dst + 2] = rgb_raw[src + 2];
|
||
|
|
rgba_raw[dst + 3] = alpha_raw[j];
|
||
|
|
}
|
||
|
|
|
||
|
|
let rgba_img = RgbaImage::from_raw(orig_width, orig_height, rgba_raw).unwrap();
|
||
|
|
results.push(rgba_img);
|
||
|
|
}
|
||
|
|
std::hint::black_box(&results);
|
||
|
|
}
|
||
|
|
let serial_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"串行流程: {:?}, 平均: {:?}",
|
||
|
|
serial_duration,
|
||
|
|
serial_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
// 并行处理流程
|
||
|
|
let start = Instant::now();
|
||
|
|
for _ in 0..iterations {
|
||
|
|
// 并行预处理
|
||
|
|
let _resized: Vec<_> = imgs
|
||
|
|
.par_iter()
|
||
|
|
.map(|img| {
|
||
|
|
img.resize_exact(target_w, target_h, image::imageops::FilterType::CatmullRom)
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
// 并行后处理
|
||
|
|
let results: Vec<_> = (0..num_images)
|
||
|
|
.into_par_iter()
|
||
|
|
.map(|i| {
|
||
|
|
let rgb_img = imgs[i].to_rgb8();
|
||
|
|
let rgb_raw = rgb_img.as_raw();
|
||
|
|
let alpha_raw = alpha_grays[i].as_raw();
|
||
|
|
let pixel_count = (orig_width * orig_height) as usize;
|
||
|
|
let mut rgba_raw = vec![0u8; pixel_count * 4];
|
||
|
|
|
||
|
|
rgba_raw
|
||
|
|
.par_chunks_mut(4)
|
||
|
|
.enumerate()
|
||
|
|
.for_each(|(j, chunk)| {
|
||
|
|
let src = j * 3;
|
||
|
|
chunk[0] = rgb_raw[src];
|
||
|
|
chunk[1] = rgb_raw[src + 1];
|
||
|
|
chunk[2] = rgb_raw[src + 2];
|
||
|
|
chunk[3] = alpha_raw[j];
|
||
|
|
});
|
||
|
|
|
||
|
|
RgbaImage::from_raw(orig_width, orig_height, rgba_raw).unwrap()
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
std::hint::black_box(&results);
|
||
|
|
}
|
||
|
|
let parallel_duration = start.elapsed();
|
||
|
|
println!(
|
||
|
|
"并行流程: {:?}, 平均: {:?}",
|
||
|
|
parallel_duration,
|
||
|
|
parallel_duration / iterations
|
||
|
|
);
|
||
|
|
|
||
|
|
let speedup = serial_duration.as_secs_f64() / parallel_duration.as_secs_f64();
|
||
|
|
println!();
|
||
|
|
println!("完整流程性能提升: {:.2}x", speedup);
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|