ysq
662 lines
19 KiB
Rust
662 lines
19 KiB
Rust
//! 🚀 编译器级性能优化 - 极致编译时优化
|
|
//!
|
|
//! 实现编译时的极致性能优化，包括：
|
|
//! - 编译器标志优化配置
|
|
//! - 编译时代码生成
|
|
//! - 内联优化和宏策略
|
|
//! - 配置引导优化 (PGO)
|
|
//! - 链接时优化 (LTO)
|
|
//! - 目标特定CPU优化
|
|
//! - 常量求值优化
|
|
//! - 零成本抽象
|
|
|
|
use std::collections::HashMap;
|
|
use std::sync::atomic::{AtomicU64, Ordering};
|
|
|
|
use anyhow::Result;
|
|
|
|
/// 🚀 编译器优化配置器
|
|
pub struct CompilerOptimizer {
|
|
/// 优化标志配置
|
|
pub optimization_flags: OptimizationFlags,
|
|
/// 代码生成配置
|
|
pub codegen_config: CodegenConfig,
|
|
/// 内联策略
|
|
pub inline_strategy: InlineStrategy,
|
|
/// 统计信息
|
|
stats: CompilerOptimizationStats,
|
|
}
|
|
|
|
/// 编译器优化标志
|
|
#[derive(Debug, Clone)]
|
|
pub struct OptimizationFlags {
|
|
/// 优化级别
|
|
pub opt_level: OptLevel,
|
|
/// 启用链接时优化
|
|
pub enable_lto: bool,
|
|
/// 启用配置引导优化
|
|
pub enable_pgo: bool,
|
|
/// 目标CPU
|
|
pub target_cpu: String,
|
|
/// 目标特性
|
|
pub target_features: Vec<String>,
|
|
/// 代码模型
|
|
pub code_model: CodeModel,
|
|
/// 启用调试信息
|
|
pub debug_info: bool,
|
|
/// 启用增量编译
|
|
pub incremental: bool,
|
|
/// 并发编译单元数
|
|
pub codegen_units: Option<usize>,
|
|
}
|
|
|
|
/// 优化级别
|
|
#[derive(Debug, Clone)]
|
|
pub enum OptLevel {
|
|
/// 无优化
|
|
None,
|
|
/// 基本优化
|
|
Less,
|
|
/// 默认优化
|
|
Default,
|
|
/// 积极优化
|
|
Aggressive,
|
|
/// 大小优化
|
|
Size,
|
|
/// 极致大小优化
|
|
SizeZ,
|
|
}
|
|
|
|
/// 代码模型
|
|
#[derive(Debug, Clone)]
|
|
pub enum CodeModel {
|
|
/// 小代码模型
|
|
Small,
|
|
/// 内核代码模型
|
|
Kernel,
|
|
/// 中等代码模型
|
|
Medium,
|
|
/// 大代码模型
|
|
Large,
|
|
}
|
|
|
|
/// 代码生成配置
|
|
#[derive(Debug, Clone)]
|
|
pub struct CodegenConfig {
|
|
/// 启用恐慌即中止
|
|
pub panic_abort: bool,
|
|
/// 溢出检查
|
|
pub overflow_checks: bool,
|
|
/// 启用胖指针LTO
|
|
pub fat_lto: bool,
|
|
/// 启用SIMD
|
|
pub enable_simd: bool,
|
|
/// 启用向量化
|
|
pub enable_vectorization: bool,
|
|
/// 启用循环展开
|
|
pub enable_loop_unrolling: bool,
|
|
/// 最大循环展开次数
|
|
pub max_unroll_count: usize,
|
|
/// 启用分支预测优化
|
|
pub enable_branch_prediction: bool,
|
|
}
|
|
|
|
/// 内联策略
|
|
#[derive(Debug, Clone)]
|
|
pub struct InlineStrategy {
|
|
/// 内联阈值
|
|
pub inline_threshold: usize,
|
|
/// 强制内联标记
|
|
pub force_inline_hot_paths: bool,
|
|
/// 禁用内联冷路径
|
|
pub no_inline_cold_paths: bool,
|
|
/// 启用跨crate内联
|
|
pub cross_crate_inline: bool,
|
|
}
|
|
|
|
/// 编译器优化统计
|
|
#[derive(Debug, Default)]
|
|
pub struct CompilerOptimizationStats {
|
|
/// 内联函数计数
|
|
pub inlined_functions: AtomicU64,
|
|
/// 常量折叠次数
|
|
pub constant_folding: AtomicU64,
|
|
/// 死代码消除次数
|
|
pub dead_code_elimination: AtomicU64,
|
|
/// 循环优化次数
|
|
pub loop_optimizations: AtomicU64,
|
|
}
|
|
|
|
impl CompilerOptimizer {
|
|
/// 创建编译器优化器
|
|
pub fn new() -> Self {
|
|
Self {
|
|
optimization_flags: OptimizationFlags::ultra_performance(),
|
|
codegen_config: CodegenConfig::ultra_performance(),
|
|
inline_strategy: InlineStrategy::aggressive(),
|
|
stats: CompilerOptimizationStats::default(),
|
|
}
|
|
}
|
|
|
|
/// 🚀 生成超高性能编译配置
|
|
pub fn generate_ultra_performance_config(&self) -> Result<CompilerConfig> {
|
|
log::info!("🚀 Generating ultra-performance compiler configuration...");
|
|
|
|
let mut rustflags = Vec::new();
|
|
|
|
// 基础优化标志
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push("opt-level=3".to_string()); // 最高优化级别
|
|
|
|
// 链接时优化
|
|
if self.optimization_flags.enable_lto {
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push("lto=fat".to_string()); // 胖LTO获得最佳优化
|
|
}
|
|
|
|
// 目标CPU优化
|
|
if !self.optimization_flags.target_cpu.is_empty() {
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push(format!("target-cpu={}", self.optimization_flags.target_cpu));
|
|
}
|
|
|
|
// 目标特性
|
|
if !self.optimization_flags.target_features.is_empty() {
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push(format!("target-feature={}", self.optimization_flags.target_features.join(",")));
|
|
}
|
|
|
|
// 代码模型
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push(format!("code-model={:?}", self.optimization_flags.code_model).to_lowercase());
|
|
|
|
// 恐慌处理
|
|
if self.codegen_config.panic_abort {
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push("panic=abort".to_string());
|
|
}
|
|
|
|
// 溢出检查
|
|
if !self.codegen_config.overflow_checks {
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push("overflow-checks=no".to_string());
|
|
}
|
|
|
|
// 代码生成单元
|
|
if let Some(units) = self.optimization_flags.codegen_units {
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push(format!("codegen-units={}", units));
|
|
}
|
|
|
|
// 内联阈值
|
|
rustflags.push("-C".to_string());
|
|
rustflags.push(format!("inline-threshold={}", self.inline_strategy.inline_threshold));
|
|
|
|
// 额外的性能优化标志
|
|
rustflags.extend([
|
|
"-C".to_string(), "embed-bitcode=no".to_string(), // 不嵌入位码以减少体积
|
|
"-C".to_string(), "debuginfo=0".to_string(), // 禁用调试信息
|
|
"-C".to_string(), "rpath=no".to_string(), // 禁用rpath
|
|
"-C".to_string(), "force-frame-pointers=no".to_string(), // 禁用帧指针
|
|
]);
|
|
|
|
let config = CompilerConfig {
|
|
rustflags,
|
|
env_vars: self.generate_env_vars(),
|
|
cargo_config: self.generate_cargo_config(),
|
|
};
|
|
|
|
log::info!("✅ Ultra-performance compiler configuration generated");
|
|
Ok(config)
|
|
}
|
|
|
|
/// 生成环境变量配置
|
|
fn generate_env_vars(&self) -> HashMap<String, String> {
|
|
let mut env_vars = HashMap::new();
|
|
|
|
// CPU特定优化
|
|
env_vars.insert("CARGO_CFG_TARGET_FEATURE".to_string(),
|
|
self.optimization_flags.target_features.join(","));
|
|
|
|
// 启用不稳定特性
|
|
env_vars.insert("RUSTC_BOOTSTRAP".to_string(), "1".to_string());
|
|
|
|
// 编译缓存设置
|
|
if self.optimization_flags.incremental {
|
|
env_vars.insert("CARGO_INCREMENTAL".to_string(), "1".to_string());
|
|
} else {
|
|
env_vars.insert("CARGO_INCREMENTAL".to_string(), "0".to_string());
|
|
}
|
|
|
|
env_vars
|
|
}
|
|
|
|
/// 生成Cargo配置
|
|
fn generate_cargo_config(&self) -> CargoConfig {
|
|
CargoConfig {
|
|
profile_release: ProfileConfig {
|
|
opt_level: 3,
|
|
lto: self.optimization_flags.enable_lto,
|
|
codegen_units: self.optimization_flags.codegen_units.unwrap_or(1),
|
|
panic: if self.codegen_config.panic_abort { "abort" } else { "unwind" }.to_string(),
|
|
overflow_checks: self.codegen_config.overflow_checks,
|
|
debug: false,
|
|
debug_assertions: false,
|
|
rpath: false,
|
|
strip: true, // 去除符号表
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 获取统计信息
|
|
pub fn get_stats(&self) -> CompilerOptimizationStats {
|
|
CompilerOptimizationStats {
|
|
inlined_functions: AtomicU64::new(self.stats.inlined_functions.load(Ordering::Relaxed)),
|
|
constant_folding: AtomicU64::new(self.stats.constant_folding.load(Ordering::Relaxed)),
|
|
dead_code_elimination: AtomicU64::new(self.stats.dead_code_elimination.load(Ordering::Relaxed)),
|
|
loop_optimizations: AtomicU64::new(self.stats.loop_optimizations.load(Ordering::Relaxed)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl OptimizationFlags {
|
|
/// 超高性能配置
|
|
pub fn ultra_performance() -> Self {
|
|
#[cfg(target_arch = "x86_64")]
|
|
let target_features = vec![
|
|
"+sse4.2".to_string(),
|
|
"+avx".to_string(),
|
|
"+avx2".to_string(),
|
|
"+fma".to_string(),
|
|
"+bmi1".to_string(),
|
|
"+bmi2".to_string(),
|
|
"+lzcnt".to_string(),
|
|
"+popcnt".to_string(),
|
|
];
|
|
|
|
#[cfg(not(target_arch = "x86_64"))]
|
|
let target_features = vec![];
|
|
Self {
|
|
opt_level: OptLevel::Aggressive,
|
|
enable_lto: true,
|
|
enable_pgo: false, // PGO需要多阶段构建
|
|
target_cpu: "native".to_string(), // 使用本机CPU特性
|
|
target_features,
|
|
code_model: CodeModel::Small,
|
|
debug_info: false,
|
|
incremental: false, // 发布版本禁用增量编译
|
|
codegen_units: Some(1), // 单个代码生成单元获得最佳优化
|
|
}
|
|
}
|
|
}
|
|
|
|
impl CodegenConfig {
|
|
/// 超高性能配置
|
|
pub fn ultra_performance() -> Self {
|
|
Self {
|
|
panic_abort: true, // 恐慌即中止，避免展开开销
|
|
overflow_checks: false, // 生产环境禁用溢出检查
|
|
fat_lto: true,
|
|
enable_simd: true,
|
|
enable_vectorization: true,
|
|
enable_loop_unrolling: true,
|
|
max_unroll_count: 16,
|
|
enable_branch_prediction: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl InlineStrategy {
|
|
/// 激进内联策略
|
|
pub fn aggressive() -> Self {
|
|
Self {
|
|
inline_threshold: 1000, // 更高的内联阈值
|
|
force_inline_hot_paths: true,
|
|
no_inline_cold_paths: true,
|
|
cross_crate_inline: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 编译器配置
|
|
#[derive(Debug, Clone)]
|
|
pub struct CompilerConfig {
|
|
pub rustflags: Vec<String>,
|
|
pub env_vars: HashMap<String, String>,
|
|
pub cargo_config: CargoConfig,
|
|
}
|
|
|
|
/// Cargo配置
|
|
#[derive(Debug, Clone)]
|
|
pub struct CargoConfig {
|
|
pub profile_release: ProfileConfig,
|
|
}
|
|
|
|
/// Profile配置
|
|
#[derive(Debug, Clone)]
|
|
pub struct ProfileConfig {
|
|
pub opt_level: u8,
|
|
pub lto: bool,
|
|
pub codegen_units: usize,
|
|
pub panic: String,
|
|
pub overflow_checks: bool,
|
|
pub debug: bool,
|
|
pub debug_assertions: bool,
|
|
pub rpath: bool,
|
|
pub strip: bool,
|
|
}
|
|
|
|
/// 🚀 编译时优化宏
|
|
#[macro_export]
|
|
macro_rules! compile_time_optimize {
|
|
// 编译时常量计算
|
|
(const $expr:expr) => {
|
|
const { $expr }
|
|
};
|
|
|
|
// 强制内联热路径
|
|
(inline_hot $fn_name:ident) => {
|
|
#[inline(always)]
|
|
#[hot]
|
|
$fn_name
|
|
};
|
|
|
|
// 标记冷路径
|
|
(cold $fn_name:ident) => {
|
|
#[inline(never)]
|
|
#[cold]
|
|
$fn_name
|
|
};
|
|
}
|
|
|
|
/// 🚀 零成本抽象特征
|
|
pub trait ZeroCostAbstraction {
|
|
type Output;
|
|
|
|
/// 编译时计算
|
|
fn compute_at_compile_time(&self) -> Self::Output;
|
|
|
|
/// 内联操作
|
|
#[inline(always)]
|
|
fn inline_operation(&self) -> Self::Output {
|
|
self.compute_at_compile_time()
|
|
}
|
|
}
|
|
|
|
/// 🚀 编译时优化的快速事件处理器
|
|
pub struct CompileTimeOptimizedEventProcessor {
|
|
/// 预计算的哈希表
|
|
hash_table: [u64; 256],
|
|
/// 预计算的路由表
|
|
route_table: [u32; 1024],
|
|
}
|
|
|
|
impl CompileTimeOptimizedEventProcessor {
|
|
/// 创建编译时优化的处理器
|
|
pub const fn new() -> Self {
|
|
Self {
|
|
hash_table: Self::precompute_hash_table(),
|
|
route_table: Self::precompute_route_table(),
|
|
}
|
|
}
|
|
|
|
/// 编译时预计算哈希表
|
|
const fn precompute_hash_table() -> [u64; 256] {
|
|
let mut table = [0u64; 256];
|
|
let mut i = 0;
|
|
|
|
while i < 256 {
|
|
// 使用编译时常量计算哈希值
|
|
table[i] = Self::const_hash(i as u8);
|
|
i += 1;
|
|
}
|
|
|
|
table
|
|
}
|
|
|
|
/// 编译时预计算路由表
|
|
const fn precompute_route_table() -> [u32; 1024] {
|
|
let mut table = [0u32; 1024];
|
|
let mut i = 0;
|
|
|
|
while i < 1024 {
|
|
// 预计算路由信息
|
|
table[i] = (i as u32) % 16; // 16个工作线程
|
|
i += 1;
|
|
}
|
|
|
|
table
|
|
}
|
|
|
|
/// 编译时常量哈希函数
|
|
const fn const_hash(input: u8) -> u64 {
|
|
// 使用简单的编译时常量哈希
|
|
let mut hash = input as u64;
|
|
hash ^= hash << 13;
|
|
hash ^= hash >> 7;
|
|
hash ^= hash << 17;
|
|
hash
|
|
}
|
|
|
|
/// 🚀 零开销事件路由
|
|
#[inline(always)]
|
|
pub fn route_event_zero_cost(&self, event_id: u8) -> u32 {
|
|
// 编译时优化：直接数组访问，无边界检查
|
|
unsafe {
|
|
*self.route_table.get_unchecked((event_id as usize) & 1023)
|
|
}
|
|
}
|
|
|
|
/// 🚀 编译时优化的哈希查找
|
|
#[inline(always)]
|
|
pub fn hash_lookup_optimized(&self, key: u8) -> u64 {
|
|
// 编译器会将这个优化为直接内存访问
|
|
self.hash_table[key as usize]
|
|
}
|
|
}
|
|
|
|
/// 🚀 SIMD编译时优化
|
|
pub struct SIMDCompileTimeOptimizer;
|
|
|
|
impl SIMDCompileTimeOptimizer {
|
|
/// 编译时SIMD向量化 - x86_64 AVX2 版本
|
|
#[cfg(target_arch = "x86_64")]
|
|
#[target_feature(enable = "avx2")]
|
|
pub unsafe fn vectorized_sum_compile_time(data: &[u64]) -> u64 {
|
|
use std::arch::x86_64::*;
|
|
|
|
if data.len() < 4 {
|
|
return data.iter().sum();
|
|
}
|
|
|
|
let chunks = data.len() / 4;
|
|
let mut sum_vec = _mm256_setzero_si256();
|
|
|
|
for i in 0..chunks {
|
|
let ptr = data.as_ptr().add(i * 4) as *const __m256i;
|
|
let vec = _mm256_loadu_si256(ptr);
|
|
sum_vec = _mm256_add_epi64(sum_vec, vec);
|
|
}
|
|
|
|
// 水平求和
|
|
let mut result = [0u64; 4];
|
|
_mm256_storeu_si256(result.as_mut_ptr() as *mut __m256i, sum_vec);
|
|
let partial_sum: u64 = result.iter().sum();
|
|
|
|
// 处理剩余元素
|
|
let remaining: u64 = data[chunks * 4..].iter().sum();
|
|
|
|
partial_sum + remaining
|
|
}
|
|
|
|
/// 编译时SIMD向量化 - 通用回退版本（非x86_64架构）
|
|
#[cfg(not(target_arch = "x86_64"))]
|
|
pub fn vectorized_sum_compile_time(data: &[u64]) -> u64 {
|
|
data.iter().sum()
|
|
}
|
|
}
|
|
|
|
/// 🚀 生成优化构建脚本
|
|
pub fn generate_build_script() -> String {
|
|
r#"
|
|
fn main() {
|
|
// 编译时CPU特性检测
|
|
if is_x86_feature_detected!("avx2") {
|
|
println!("cargo:rustc-cfg=has_avx2");
|
|
}
|
|
|
|
if is_x86_feature_detected!("avx512f") {
|
|
println!("cargo:rustc-cfg=has_avx512");
|
|
}
|
|
|
|
// 编译时目标特性启用
|
|
println!("cargo:rustc-env=TARGET_FEATURE=+sse4.2,+avx,+avx2,+fma");
|
|
|
|
// 链接时优化
|
|
println!("cargo:rustc-link-arg=-fuse-ld=lld"); // 使用更快的链接器
|
|
|
|
// 编译时常量配置
|
|
println!("cargo:rustc-env=COMPILE_TIME_OPTIMIZED=1");
|
|
|
|
// Profile引导优化设置
|
|
if std::env::var("ENABLE_PGO").is_ok() {
|
|
println!("cargo:rustc-link-arg=-fprofile-use");
|
|
}
|
|
}
|
|
"#.to_string()
|
|
}
|
|
|
|
/// 🚀 生成.cargo/config.toml
|
|
pub fn generate_cargo_config_toml() -> String {
|
|
r#"
|
|
[build]
|
|
rustflags = [
|
|
"-C", "opt-level=3",
|
|
"-C", "lto=fat",
|
|
"-C", "panic=abort",
|
|
"-C", "codegen-units=1",
|
|
"-C", "target-cpu=native",
|
|
"-C", "embed-bitcode=no",
|
|
"-C", "debuginfo=0",
|
|
"-C", "overflow-checks=no",
|
|
"-C", "inline-threshold=1000",
|
|
]
|
|
|
|
[profile.release]
|
|
opt-level = 3
|
|
lto = "fat"
|
|
codegen-units = 1
|
|
panic = "abort"
|
|
overflow-checks = false
|
|
debug = false
|
|
debug-assertions = false
|
|
rpath = false
|
|
strip = true
|
|
|
|
[profile.release-with-debug]
|
|
inherits = "release"
|
|
debug = true
|
|
strip = false
|
|
|
|
[target.x86_64-unknown-linux-gnu]
|
|
linker = "clang"
|
|
rustflags = [
|
|
"-C", "link-arg=-fuse-ld=lld",
|
|
"-C", "link-arg=-Wl,--gc-sections",
|
|
"-C", "link-arg=-Wl,--icf=all",
|
|
"-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
|
|
]
|
|
|
|
[target.x86_64-apple-darwin]
|
|
rustflags = [
|
|
"-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
|
|
]
|
|
|
|
[target.x86_64-pc-windows-msvc]
|
|
rustflags = [
|
|
"-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
|
|
]
|
|
"#.to_string()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_compiler_optimizer_creation() {
|
|
let optimizer = CompilerOptimizer::new();
|
|
assert!(optimizer.optimization_flags.enable_lto);
|
|
assert_eq!(optimizer.optimization_flags.opt_level as u8, OptLevel::Aggressive as u8);
|
|
}
|
|
|
|
#[test]
|
|
fn test_compile_time_processor() {
|
|
const PROCESSOR: CompileTimeOptimizedEventProcessor = CompileTimeOptimizedEventProcessor::new();
|
|
|
|
let route = PROCESSOR.route_event_zero_cost(42);
|
|
assert!(route < 16); // 应该路由到16个工作线程之一
|
|
|
|
let hash = PROCESSOR.hash_lookup_optimized(100);
|
|
assert!(hash > 0); // 哈希值应该非零
|
|
}
|
|
|
|
#[test]
|
|
fn test_ultra_performance_config() {
|
|
let flags = OptimizationFlags::ultra_performance();
|
|
assert!(flags.enable_lto);
|
|
assert_eq!(flags.target_cpu, "native");
|
|
assert!(!flags.target_features.is_empty());
|
|
|
|
let codegen = CodegenConfig::ultra_performance();
|
|
assert!(codegen.panic_abort);
|
|
assert!(!codegen.overflow_checks);
|
|
assert!(codegen.enable_simd);
|
|
}
|
|
|
|
#[test]
|
|
fn test_compiler_config_generation() {
|
|
let optimizer = CompilerOptimizer::new();
|
|
let config = optimizer.generate_ultra_performance_config().unwrap();
|
|
|
|
assert!(!config.rustflags.is_empty());
|
|
assert!(config.rustflags.contains(&"-C".to_string()));
|
|
assert!(config.rustflags.contains(&"opt-level=3".to_string()));
|
|
|
|
assert!(config.env_vars.contains_key("CARGO_INCREMENTAL"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_simd_compile_time_optimization() {
|
|
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
|
|
if is_x86_feature_detected!("avx2") {
|
|
let data = vec![1u64, 2, 3, 4, 5, 6, 7, 8];
|
|
let sum = unsafe { SIMDCompileTimeOptimizer::vectorized_sum_compile_time(&data) };
|
|
assert_eq!(sum, 36); // 1+2+3+4+5+6+7+8 = 36
|
|
}
|
|
|
|
#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
|
|
{
|
|
let data = vec![1u64, 2, 3, 4, 5, 6, 7, 8];
|
|
let sum = SIMDCompileTimeOptimizer::vectorized_sum_compile_time(&data);
|
|
assert_eq!(sum, 36); // 1+2+3+4+5+6+7+8 = 36
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_build_script_generation() {
|
|
let build_script = generate_build_script();
|
|
assert!(build_script.contains("avx2"));
|
|
assert!(build_script.contains("TARGET_FEATURE"));
|
|
assert!(build_script.contains("lld"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_cargo_config_generation() {
|
|
let config = generate_cargo_config_toml();
|
|
assert!(config.contains("opt-level = 3"));
|
|
assert!(config.contains("lto = \"fat\""));
|
|
assert!(config.contains("target-cpu=native"));
|
|
assert!(config.contains("panic = \"abort\""));
|
|
}
|
|
} |