use crate::ir::{ElemType, KernelVariant, KERNEL_TEMPLATES};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DispatchEntry {
pub key: String,
pub selected_variant: String,
pub execution_time_ms: f64,
pub gpu_model: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DispatchTable {
pub entries: HashMap<String, DispatchEntry>,
pub version: String,
}
impl Default for DispatchTable {
fn default() -> Self {
Self::new()
}
}
impl DispatchTable {
pub fn new() -> Self {
DispatchTable {
entries: HashMap::new(),
version: "1.0".to_string(),
}
}
pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
serde_json::from_str(json)
}
pub fn to_json(&self) -> Result<String, serde_json::Error> {
serde_json::to_string_pretty(self)
}
pub fn get_entry(&self, variant: &KernelVariant) -> Option<&DispatchEntry> {
let key = variant.dispatch_key();
self.entries.get(&key)
}
pub fn insert_entry(&mut self, entry: DispatchEntry) {
self.entries.insert(entry.key.clone(), entry);
}
pub fn generate_default_entries(&mut self, gpu_model: &str) {
for &name in KERNEL_TEMPLATES {
for elem in [ElemType::F32, ElemType::F16, ElemType::BF16] {
let variant = KernelVariant {
name: name.to_string(),
elem,
shape_params: vec![1024], };
let key = variant.dispatch_key();
self.entries.insert(
key.clone(),
DispatchEntry {
key,
selected_variant: format!("{}_{}", name, elem.name()),
execution_time_ms: 1.0,
gpu_model: gpu_model.to_string(),
},
);
}
}
}
}
pub fn dispatch_kernel(table: &DispatchTable, variant: &KernelVariant) -> Option<String> {
table.get_entry(variant).map(|e| e.selected_variant.clone())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_dispatch_table_new() {
let table = DispatchTable::new();
assert!(table.entries.is_empty());
}
#[test]
fn test_generate_default_entries() {
let mut table = DispatchTable::new();
table.generate_default_entries("RTX_3090");
assert!(!table.entries.is_empty());
assert_eq!(table.entries.len(), 27);
}
#[test]
fn test_dispatch_kernel() {
let mut table = DispatchTable::new();
table.generate_default_entries("RTX_3090");
let variant = KernelVariant {
name: "vector_add".to_string(),
elem: ElemType::F32,
shape_params: vec![1024],
};
let result = dispatch_kernel(&table, &variant);
assert!(result.is_some());
}
}