Skip to content

Commit

Permalink
refactor: re-organize build script
Browse files Browse the repository at this point in the history
  • Loading branch information
@huitseeker
huitseeker committed Jan 7, 2024
1 parent 9cfc26b commit 3377c11
Showing 1 changed file with 98 additions and 154 deletions.
252 changes: 98 additions & 154 deletions build.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,189 +2,133 @@ use std::env;
use std::path::PathBuf;

fn main() {
// account for cross-compilation [by examining environment variable]
let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();

// Set CXX environment variable to choose alternative C compiler.
// Optimization level depends on whether or not --release is passed
// or implied.
compile_source(
"grumpkin_pippenger.cpp",
"__BLST_PORTABLE__",
"grumpkin_msm",
&target_arch,
);
compile_source(
"pasta_pippenger.cpp",
"__PASTA_PORTABLE__",
"pasta_msm",
&target_arch,
);

if cfg!(target_os = "windows") && !cfg!(target_env = "msvc") {
return;
}

if cuda_available() {
let mut implement_sort: bool = true;
compile_cuda("cuda/bn254.cu", "bn256_msm_cuda", implement_sort);
implement_sort = false;
compile_cuda("cuda/grumpkin.cu", "grumpkin_msm_cuda", implement_sort);
compile_cuda("cuda/pallas.cu", "pallas_msm_cuda", implement_sort);
compile_cuda("cuda/vesta.cu", "vesta_msm_cuda", implement_sort);
println!("cargo:rerun-if-changed=cuda");
}
println!("cargo:rerun-if-env-changed=NVCC");
}

fn compile_source(
file_name: &str,
def: &str,
output_name: &str,
target_arch: &str,
) {
let mut cc = cc::Build::new();
cc.cpp(true);

let c_src_dir = PathBuf::from("src");
let files = vec![
c_src_dir.join("grumpkin_pippenger.cpp"),
// c_src_dir.join("pasta_pippenger.cpp"),
];
let mut cc_def = None;
let file = c_src_dir.join(file_name);
let cc_def = determine_cc_def(target_arch, def);

match (cfg!(feature = "portable"), cfg!(feature = "force-adx")) {
(true, false) => {
println!("Compiling in portable mode without ISA extensions");
cc_def = Some("__BLST_PORTABLE__");
}
(false, true) => {
if target_arch.eq("x86_64") {
println!("Enabling ADX support via `force-adx` feature");
cc_def = Some("__ADX__");
} else {
println!("`force-adx` is ignored for non-x86_64 targets");
}
}
(false, false) => {
#[cfg(target_arch = "x86_64")]
if target_arch.eq("x86_64") && std::is_x86_feature_detected!("adx")
{
println!("Enabling ADX because it was detected on the host");
cc_def = Some("__ADX__");
}
}
(true, true) => panic!(
"Cannot compile with both `portable` and `force-adx` features"
),
}

cc.flag_if_supported("-mno-avx") // avoid costly transitions
.flag_if_supported("-fno-builtin")
.flag_if_supported("-std=c++11")
.flag_if_supported("-Wno-unused-command-line-argument");
if !cfg!(debug_assertions) {
cc.define("NDEBUG", None);
}
if let Some(def) = cc_def {
cc.define(def, None);
common_build_configurations(&mut cc);
if let Some(cc_def) = cc_def {
cc.define(&cc_def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
cc.include(include);
}
if let Some(include) = env::var_os("DEP_SEMOLINA_C_INCLUDE") {
cc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_ROOT") {
cc.include(include);
}
cc.files(&files).compile("grumpkin_msm");

// ============================================================
// ====================== PASTA BINDINGS ======================
// ============================================================

// Set CXX environment variable to choose alternative C compiler.
// Optimization level depends on whether or not --release is passed
// or implied.
let mut cc = cc::Build::new();
cc.cpp(true);
cc.file(file).compile(output_name);
}

let c_src_dir = PathBuf::from("src");
let files = vec![c_src_dir.join("pasta_pippenger.cpp")];
let mut cc_def = None;
fn common_build_configurations(cc: &mut cc::Build) {
cc.flag_if_supported("-mno-avx")
.flag_if_supported("-fno-builtin")
.flag_if_supported("-std=c++11")
.flag_if_supported("-Wno-unused-command-line-argument");
if !cfg!(debug_assertions) {
cc.define("NDEBUG", None);
}
}

fn determine_cc_def(target_arch: &str, default_def: &str) -> Option<String> {
match (cfg!(feature = "portable"), cfg!(feature = "force-adx")) {
(true, false) => {
println!("Compiling in portable mode without ISA extensions");
cc_def = Some("__PASTA_PORTABLE__");
}
(false, true) => {
if target_arch.eq("x86_64") {
println!("Enabling ADX support via `force-adx` feature");
cc_def = Some("__ADX__");
} else {
println!("`force-adx` is ignored for non-x86_64 targets");
}
}
(false, false) => {
#[cfg(target_arch = "x86_64")]
if target_arch.eq("x86_64") && std::is_x86_feature_detected!("adx")
{
println!("Enabling ADX because it was detected on the host");
cc_def = Some("__ADX__");
}
(true, false) => Some(default_def.to_string()),
(false, true) if target_arch == "x86_64" => Some("__ADX__".to_string()),
(false, false)
if target_arch == "x86_64"
&& std::is_x86_feature_detected!("adx") =>
{
Some("__ADX__".to_string())
}
(true, true) => panic!(
"Cannot compile with both `portable` and `force-adx` features"
),
_ => None,
}
}

cc.flag_if_supported("-mno-avx") // avoid costly transitions
.flag_if_supported("-fno-builtin")
.flag_if_supported("-std=c++11")
.flag_if_supported("-Wno-unused-command-line-argument");
if !cfg!(debug_assertions) {
cc.define("NDEBUG", None);
fn cuda_available() -> bool {
match env::var("NVCC") {
Ok(var) => which::which(var).is_ok(),
Err(_) => which::which("nvcc").is_ok(),
}
if let Some(def) = cc_def {
cc.define(def, None);
}

fn compile_cuda(file_name: &str, output_name: &str, implement_sort: bool) {
let mut nvcc = cc::Build::new();
nvcc.cuda(true);
nvcc.flag("-arch=sm_80");
nvcc.flag("-gencode").flag("arch=compute_70,code=sm_70");
nvcc.flag("-t0");
#[cfg(not(target_env = "msvc"))]
nvcc.flag("-Xcompiler").flag("-Wno-unused-function");
nvcc.define("TAKE_RESPONSIBILITY_FOR_ERROR_MESSAGE", None);
#[cfg(feature = "cuda-mobile")]
nvcc.define("NTHREADS", "128");

if let Some(def) = determine_cc_def(
&env::var("CARGO_CFG_TARGET_ARCH").unwrap(),
"__CUDA_PORTABLE__",
) {
nvcc.define(&def, None);
}

if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SEMOLINA_C_INCLUDE") {
cc.include(include);
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_ROOT") {
cc.include(include);
}
cc.files(&files).compile("pasta_msm");

if cfg!(target_os = "windows") && !cfg!(target_env = "msvc") {
return;
nvcc.include(include);
}
// Detect if there is CUDA compiler and engage "cuda" feature accordingly
let nvcc = match env::var("NVCC") {
Ok(var) => which::which(var),
Err(_) => which::which("nvcc"),
};
if nvcc.is_ok() {
let mut nvcc = cc::Build::new();
nvcc.cuda(true);
nvcc.flag("-arch=sm_80");
nvcc.flag("-gencode").flag("arch=compute_70,code=sm_70");
nvcc.flag("-t0");
#[cfg(not(target_env = "msvc"))]
nvcc.flag("-Xcompiler").flag("-Wno-unused-function");
nvcc.define("TAKE_RESPONSIBILITY_FOR_ERROR_MESSAGE", None);
#[cfg(feature = "cuda-mobile")]
nvcc.define("NTHREADS", "128");
if let Some(def) = cc_def {
nvcc.define(def, None);
}

if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_ROOT") {
nvcc.include(include);
}
nvcc.clone().file("cuda/bn254.cu").compile("bn256_msm_cuda");
if implement_sort {
nvcc.file(file_name).compile(output_name);
} else {
nvcc.define("__MSM_SORT_DONT_IMPLEMENT__", None)
.file("cuda/grumpkin.cu")
.compile("grumpkin_msm_cuda");

let mut nvcc = cc::Build::new();
nvcc.cuda(true);
nvcc.flag("-arch=sm_80");
nvcc.flag("-gencode").flag("arch=compute_70,code=sm_70");
nvcc.flag("-t0");
#[cfg(not(target_env = "msvc"))]
nvcc.flag("-Xcompiler").flag("-Wno-unused-function");
nvcc.define("TAKE_RESPONSIBILITY_FOR_ERROR_MESSAGE", None);
#[cfg(feature = "cuda-mobile")]
nvcc.define("NTHREADS", "128");
if let Some(def) = cc_def {
nvcc.define(def, None);
}

if let Some(include) = env::var_os("DEP_SEMOLINA_C_INCLUDE") {
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_ROOT") {
nvcc.include(include);
}
nvcc.clone()
.define("__MSM_SORT_DONT_IMPLEMENT__", None)
.file("cuda/pallas.cu")
.compile("pallas_msm_cuda");
nvcc.define("__MSM_SORT_DONT_IMPLEMENT__", None)
.file("cuda/vesta.cu")
.compile("vesta_msm_cuda");

println!("cargo:rerun-if-changed=cuda");
println!("cargo:rerun-if-env-changed=CXXFLAGS");
println!("cargo:rustc-cfg=feature=\"cuda\"");
.file(file_name)
.compile(output_name);
}
println!("cargo:rerun-if-env-changed=NVCC");
}

0 comments on commit 3377c11

Please sign in to comment.