ispc-texcomp 0.1.20

Rust bindings for Intel's ISPC texture compressor.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

/*
    ISPC project file builds the kernels as such:
    <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">ispc -O2 "%(Filename).ispc" -o "$(TargetDir)%(Filename).obj" -h "$(ProjectDir)%(Filename)_ispc.h" --target=sse2,sse4,avx,avx2 --opt=fast-math</Command>
    <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(TargetDir)%(Filename).obj;$(TargetDir)%(Filename)_sse2.obj;$(TargetDir)%(Filename)_sse4.obj;$(TargetDir)%(Filename)_avx.obj;$(TargetDir)%(Filename)_avx2.obj;</Outputs>
*/

#[cfg(feature = "ispc")]
use glob::glob;
#[cfg(feature = "ispc")]
use std::fs;

#[cfg(feature = "ispc")]
fn clean_target(target_name: &str, target: &str) {
    let target_files = format!("src/ispc/*{}{}*", target_name, target);
    println!("remove lib kernel {}", target_files);
    for entry in glob(target_files.as_str()).unwrap() {
        match entry {
            Ok(target_file) => println!("{:?}", fs::remove_file(target_file).unwrap()),
            Err(e) => println!("{:?}", e),
        }
    }
}

#[cfg(feature = "ispc")]
fn compile_kernel() {
    use ispc_compile::TargetISA;
    use std::env;

    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
    let target = env::var("TARGET").unwrap();
    println!("cargo:rerun-if-changed=src/kernels/*");

    clean_target("kernel", &target);
    clean_target("kernel_astc", &target);

    let target_isas = match target_arch.as_str() {
        "x86" | "x86_64" => vec![
            TargetISA::SSE2i32x4,
            TargetISA::SSE4i32x4,
            TargetISA::AVX1i32x8,
            TargetISA::AVX2i32x8,
            TargetISA::AVX512KNLi32x16,
            TargetISA::AVX512SKXi32x16,
        ],
        "aarch64" | "arm" => vec![TargetISA::Neoni32x4],
        _ => vec![],
    };

    ispc_compile::Config::new()
        .file("src/kernels/kernel.ispc")
        .optimization_opt(ispc_compile::OptimizationOpt::FastMath)
        .target_isas(target_isas.clone())
        .out_dir("src/ispc")
        .compile("kernel");

    ispc_compile::Config::new()
        .file("src/kernels/kernel_astc.ispc")
        .optimization_opt(ispc_compile::OptimizationOpt::FastMath)
        .target_isas(target_isas)
        .out_dir("src/ispc")
        .compile("kernel_astc");

    let target_os_family = env::var("CARGO_CFG_TARGET_FAMILY").unwrap();

    if target_os_family == "windows" {
        let outdir = env::var("OUT_DIR").unwrap();
        cc::Build::new()
            .cpp(true)
            .file("src/ispc/ispc_texcomp_astc.cpp")
            .include(outdir)
            .out_dir("src/ispc")
            .compile(&format!("ispc_texcomp_astc{}", target));
    }
}

#[cfg(not(feature = "ispc"))]
fn compile_kernel() {
    use std::env;
    ispc_rt::PackagedModule::new("kernel")
        .lib_path("src/ispc")
        .link();

    ispc_rt::PackagedModule::new("kernel_astc")
        .lib_path("src/ispc")
        .link();

    if env::var("CARGO_CFG_TARGET_FAMILY").unwrap() == "windows" {
        println!("cargo:rustc-link-search=native=src/ispc");
        println!(
            "cargo:rustc-link-lib=static=ispc_texcomp_astc{}",
            env::var("TARGET").unwrap()
        );
    }
}

fn main() {
    compile_kernel();
}