use crate::error::TptpResult;
use crate::ffi::tptir_ffi;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CompilationTarget {
TptIsaText = 0,
LlvmIr = 1,
TptirBinary = 2,
}
#[derive(Debug, Clone)]
pub struct CompilationOptions {
pub target: CompilationTarget,
pub opt_level: u32,
pub debug_info: bool,
pub target_arch: Option<String>,
pub extra_flags: Vec<String>,
}
impl Default for CompilationOptions {
fn default() -> Self {
CompilationOptions {
target: CompilationTarget::TptIsaText,
opt_level: 2,
debug_info: false,
target_arch: None,
extra_flags: Vec::new(),
}
}
}
pub struct TptirCompiler {
#[allow(dead_code)]
context: tptir_ffi::TptirCompilerHandle,
options: CompilationOptions,
}
impl TptirCompiler {
pub fn new() -> TptpResult<Self> {
let context = tptir_ffi::TptirCompilerHandle::new()?;
Ok(TptirCompiler {
context,
options: CompilationOptions::default(),
})
}
pub fn with_options(options: CompilationOptions) -> TptpResult<Self> {
let context = tptir_ffi::TptirCompilerHandle::new()?;
Ok(TptirCompiler { context, options })
}
pub fn version() -> String {
tptir_ffi::get_tptir_version()
}
pub fn compile(&self, source: &str) -> TptpResult<String> {
tptir_ffi::compile_kernel(source, self.options.target as i32)
}
pub fn compile_kernel(&self, source: &str, kernel_name: &str) -> TptpResult<String> {
let _ = kernel_name;
self.compile(source)
}
pub fn compile_parameterized(
&self,
template: &str,
params: &[(&str, &str)],
) -> TptpResult<String> {
let mut source = template.to_owned();
for (key, value) in params {
let placeholder = format!("{{{{{}}}}}", key);
source = source.replace(&placeholder, value);
}
self.compile(&source)
}
pub fn compile_gemm_template(
tile_m: u32,
tile_n: u32,
tile_k: u32,
vec_width: u32,
unroll: u32,
) -> TptpResult<String> {
let template = include_str!("../../tptir/tptir_gemm.mlir");
let compiler = TptirCompiler::new()?;
compiler.compile_parameterized(
template,
&[
("TILE_M", &tile_m.to_string()),
("TILE_N", &tile_n.to_string()),
("TILE_K", &tile_k.to_string()),
("VEC_WIDTH", &vec_width.to_string()),
("UNROLL", &unroll.to_string()),
],
)
}
pub fn options(&self) -> &CompilationOptions {
&self.options
}
pub fn set_options(&mut self, options: CompilationOptions) {
self.options = options;
}
}
impl Default for TptirCompiler {
fn default() -> Self {
Self::new().expect("failed to create TPTIR compiler")
}
}
pub fn compile(source: &str) -> TptpResult<String> {
let compiler = TptirCompiler::new()?;
compiler.compile(source)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_compiler_version() {
let version = TptirCompiler::version();
assert!(!version.is_empty());
}
#[test]
fn test_compiler_creation() {
let compiler = TptirCompiler::new();
assert!(compiler.is_ok());
}
#[test]
fn test_parameterized_substitution() {
let template = "tile_m={{TILE_M}} tile_k={{TILE_K}} vec={{VEC_WIDTH}}";
let compiler = TptirCompiler::new().unwrap();
let mut source = template.to_owned();
for (k, v) in &[("TILE_M", "128"), ("TILE_K", "32"), ("VEC_WIDTH", "8")] {
source = source.replace(&format!("{{{{{}}}}}", k), v);
}
assert_eq!(source, "tile_m=128 tile_k=32 vec=8");
let result = compiler.compile_parameterized(
template,
&[("TILE_M", "64"), ("TILE_K", "16"), ("VEC_WIDTH", "4")],
);
assert!(result.is_ok());
}
}