mirrors/ZLUDA
0
0
Fork 0
mirror of https://github.com/vosen/ZLUDA.git synced 2025-09-27 19:59:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

comgr: refactor

Browse source
This commit is contained in:
Joëlle van Essen 2025-08-14 08:45:48 +02:00
commit 02de35efb0
No known key found for this signature in database
GPG key ID: 28D3B5CDD4B43882
1 changed files with 36 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

62
comgr/src/lib.rs
View file

@ -138,11 +138,23 @@ impl<'a> DataSet<'a> {
Ok(()) Ok(())
} }
pub fn from_data(comgr: &'a Comgr, data: impl Iterator<Item = Data>) -> Result<Self, Error> {
let dataset = Self::new(comgr)?;
for data in data {
dataset.add(&data)?;
}
Ok(dataset)
}
fn get_data(&self, kind: DataKind, index: usize) -> Result<Data, Error> { fn get_data(&self, kind: DataKind, index: usize) -> Result<Data, Error> {
let mut handle = 0u64; let mut handle = 0u64;
call_dispatch!(self.comgr => amd_comgr_action_data_get_data(self, kind, { index }, { std::ptr::from_mut(&mut handle).cast() })); call_dispatch!(self.comgr => amd_comgr_action_data_get_data(self, kind, { index }, { std::ptr::from_mut(&mut handle).cast() }));
Ok(Data(handle)) Ok(Data(handle))
} }
fn get_content(&self, comgr: &Comgr, kind: DataKind, index: usize) -> Result<Vec<u8>, Error> {
self.get_data(kind, index).map(|data| data.copy_content(comgr))?
}
} }
struct Data(u64); struct Data(u64);
@ -196,28 +208,24 @@ pub fn compile_bitcode(
attributes_buffer: &[u8], attributes_buffer: &[u8],
compiler_hook: Option<&dyn Fn(&Vec<u8>, String)>, compiler_hook: Option<&dyn Fn(&Vec<u8>, String)>,
) -> Result<Vec<u8>, Error> { ) -> Result<Vec<u8>, Error> {
let bitcode_data_set = DataSet::new(comgr)?; let bitcode_data_set = DataSet::from_data(
let main_bitcode_data = Data::new(comgr, DataKind::Bc, c"zluda.bc", main_buffer)?; comgr,
bitcode_data_set.add(&main_bitcode_data)?; [
let stdlib_bitcode_data = Data::new(comgr, DataKind::Bc, c"ptx_impl.bc", ptx_impl)?; Data::new(comgr, DataKind::Bc, c"zluda.bc", main_buffer)?,
bitcode_data_set.add(&stdlib_bitcode_data)?; Data::new(comgr, DataKind::Bc, c"ptx_impl.bc", ptx_impl)?,
let attributes_bitcode_data = Data::new(comgr, DataKind::Bc, c"attributes.bc", attributes_buffer)?,
Data::new(comgr, DataKind::Bc, c"attributes.bc", attributes_buffer)?; ].into_iter(),
bitcode_data_set.add(&attributes_bitcode_data)?; )?;
let linking_info = ActionInfo::new(comgr)?; let linking_info = ActionInfo::new(comgr)?;
let linked_data_set = let linked_data_set =
comgr.do_action(ActionKind::LinkBcToBc, &linking_info, &bitcode_data_set)?; comgr.do_action(ActionKind::LinkBcToBc, &linking_info, &bitcode_data_set)?;
if let Some(hook) = compiler_hook { if let Some(hook) = compiler_hook {
// Run compiler hook on human-readable LLVM IR // Run compiler hook on human-readable LLVM IR
let data = linked_data_set.get_data(DataKind::Bc, 0)?; let data = linked_data_set.get_content(comgr, DataKind::Bc, 0)?;
let data = data.copy_content(comgr)?;
let data = ptx::bitcode_to_ir(data); let data = ptx::bitcode_to_ir(data);
hook(&data, String::from("linked.ll")); hook(&data, String::from("linked.ll"));
} }
let compile_to_exec = ActionInfo::new(comgr)?;
compile_to_exec.set_isa_name(gcn_arch)?;
compile_to_exec.set_language(Language::LlvmIr)?;
let common_options = [ let common_options = [
// This makes no sense, but it makes ockl linking work // This makes no sense, but it makes ockl linking work
c"-Xclang", c"-Xclang",
@ -249,14 +257,16 @@ pub fn compile_bitcode(
c"-inlinehint-threshold=3250", c"-inlinehint-threshold=3250",
] ]
}; };
let compile_to_exec = ActionInfo::new(comgr)?;
compile_to_exec.set_isa_name(gcn_arch)?;
compile_to_exec.set_language(Language::LlvmIr)?;
compile_to_exec.set_options(common_options.chain(opt_options))?; compile_to_exec.set_options(common_options.chain(opt_options))?;
let exec_data_set = comgr.do_action( let exec_data_set = comgr.do_action(
ActionKind::CompileSourceToExecutable, ActionKind::CompileSourceToExecutable,
&compile_to_exec, &compile_to_exec,
&linked_data_set, &linked_data_set,
)?; )?;
let executable = exec_data_set.get_data(DataKind::Executable, 0)?; let executable = exec_data_set.get_content(comgr, DataKind::Executable, 0);
let executable = executable.copy_content(comgr);
if let Some(hook) = compiler_hook { if let Some(hook) = compiler_hook {
// Run compiler hook for executable // Run compiler hook for executable
hook( hook(
@ -272,9 +282,8 @@ pub fn compile_bitcode(
&action_info, &action_info,
&exec_data_set, &exec_data_set,
)?; )?;
let disassembly = disassembly.get_data(DataKind::Source, 0)?; let disassembly = disassembly.get_content(comgr, DataKind::Source, 0)?;
let disassembly = disassembly.copy_content(comgr); hook(&disassembly, String::from("asm"))
hook(&disassembly.unwrap_or(Vec::new()), String::from("asm"))
} }
executable executable
} }
@ -296,14 +305,15 @@ pub fn get_symbols(comgr: &Comgr, elf: &[u8]) -> Result<Vec<(u32, String)>, Erro
} }
pub fn get_clang_version(comgr: &Comgr) -> Result<String, Error> { pub fn get_clang_version(comgr: &Comgr) -> Result<String, Error> {
let version_string_set = DataSet::new(comgr)?; let version_string_set = DataSet::from_data(
let version_string = Data::new(
comgr, comgr,
DataKind::Source, iter::once(Data::new(
c"version.cpp", comgr,
b"__clang_version__", DataKind::Source,
c"version.cpp",
b"__clang_version__",
)?),
)?; )?;
version_string_set.add(&version_string)?;
let preprocessor_info = ActionInfo::new(comgr)?; let preprocessor_info = ActionInfo::new(comgr)?;
preprocessor_info.set_language(Language::Hip)?; preprocessor_info.set_language(Language::Hip)?;
preprocessor_info.set_options(iter::once(c"-P"))?; preprocessor_info.set_options(iter::once(c"-P"))?;
@ -312,8 +322,8 @@ pub fn get_clang_version(comgr: &Comgr) -> Result<String, Error> {
&preprocessor_info, &preprocessor_info,
&version_string_set, &version_string_set,
)?; )?;
let data = preprocessed.get_data(DataKind::Source, 0)?; let data = preprocessed.get_content(comgr, DataKind::Source, 0)?;
String::from_utf8(trim_whitespace_and_quotes(data.copy_content(comgr)?)?) String::from_utf8(trim_whitespace_and_quotes(data)?)
.map_err(|_| Error::UNKNOWN) .map_err(|_| Error::UNKNOWN)
} }