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

Remove sreg address space

Browse source
This commit is contained in:
Andrzej Janik 2024-09-13 19:46:49 +02:00
commit 415639da72
9 changed files with 14 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

2
ptx/src/pass/convert_to_stateful_memory_access.rs
View file

@ -489,7 +489,7 @@ fn convert_to_stateful_memory_access_postprocess(
let (old_operand_type, old_operand_space, _) = id_defs.get_typed(operand)?; let (old_operand_type, old_operand_space, _) = id_defs.get_typed(operand)?;
let converting_id = id_defs let converting_id = id_defs
.register_intermediate(Some((old_operand_type.clone(), old_operand_space))); .register_intermediate(Some((old_operand_type.clone(), old_operand_space)));
let kind = if space_is_compatible(new_operand_space, ast::StateSpace::Reg) { let kind = if new_operand_space == ast::StateSpace::Reg {
ConversionKind::Default ConversionKind::Default
} else { } else {
ConversionKind::PtrToPtr ConversionKind::PtrToPtr

1
ptx/src/pass/emit_llvm.rs
View file

@ -656,7 +656,6 @@ fn get_state_space(space: ast::StateSpace) -> Result<u32, TranslateError> {
match space { match space {
ast::StateSpace::Reg => Ok(PRIVATE_ADDRESS_SPACE), ast::StateSpace::Reg => Ok(PRIVATE_ADDRESS_SPACE),
ast::StateSpace::Generic => Ok(GENERIC_ADDRESS_SPACE), ast::StateSpace::Generic => Ok(GENERIC_ADDRESS_SPACE),
ast::StateSpace::Sreg => Ok(PRIVATE_ADDRESS_SPACE),
ast::StateSpace::Param => Err(TranslateError::Todo), ast::StateSpace::Param => Err(TranslateError::Todo),
ast::StateSpace::ParamEntry => Err(TranslateError::Todo), ast::StateSpace::ParamEntry => Err(TranslateError::Todo),
ast::StateSpace::ParamFunc => Err(TranslateError::Todo), ast::StateSpace::ParamFunc => Err(TranslateError::Todo),

2
ptx/src/pass/emit_spirv.rs
View file

@ -469,7 +469,6 @@ fn space_to_spirv(this: ast::StateSpace) -> spirv::StorageClass {
ast::StateSpace::Shared => spirv::StorageClass::Workgroup, ast::StateSpace::Shared => spirv::StorageClass::Workgroup,
ast::StateSpace::Param => spirv::StorageClass::Function, ast::StateSpace::Param => spirv::StorageClass::Function,
ast::StateSpace::Reg => spirv::StorageClass::Function, ast::StateSpace::Reg => spirv::StorageClass::Function,
ast::StateSpace::Sreg => spirv::StorageClass::Input,
ast::StateSpace::ParamEntry ast::StateSpace::ParamEntry
| ast::StateSpace::ParamFunc | ast::StateSpace::ParamFunc
| ast::StateSpace::SharedCluster | ast::StateSpace::SharedCluster
@ -693,7 +692,6 @@ fn emit_variable<'input>(
ast::StateSpace::Shared => (false, spirv::StorageClass::Workgroup), ast::StateSpace::Shared => (false, spirv::StorageClass::Workgroup),
ast::StateSpace::Const => (false, spirv::StorageClass::UniformConstant), ast::StateSpace::Const => (false, spirv::StorageClass::UniformConstant),
ast::StateSpace::Generic => todo!(), ast::StateSpace::Generic => todo!(),
ast::StateSpace::Sreg => todo!(),
ast::StateSpace::ParamEntry ast::StateSpace::ParamEntry
| ast::StateSpace::ParamFunc | ast::StateSpace::ParamFunc
| ast::StateSpace::SharedCluster | ast::StateSpace::SharedCluster

4
ptx/src/pass/expand_arguments.rs
View file

@ -63,9 +63,9 @@ impl<'a, 'b> FlattenArguments<'a, 'b> {
} else { } else {
return Err(TranslateError::UntypedSymbol); return Err(TranslateError::UntypedSymbol);
}; };
if state_space == ast::StateSpace::Reg || state_space == ast::StateSpace::Sreg { if state_space == ast::StateSpace::Reg {
let (reg_type, reg_space) = self.id_def.get_typed(reg)?; let (reg_type, reg_space) = self.id_def.get_typed(reg)?;
if !space_is_compatible(reg_space, ast::StateSpace::Reg) { if reg_space != ast::StateSpace::Reg {
return Err(error_mismatched_type()); return Err(error_mismatched_type());
} }
let reg_scalar_type = match reg_type { let reg_scalar_type = match reg_type {

1
ptx/src/pass/extract_globals.rs
View file

@ -273,7 +273,6 @@ fn space_to_ptx_name(this: ast::StateSpace) -> &'static str {
ast::StateSpace::Const => "const", ast::StateSpace::Const => "const",
ast::StateSpace::Local => "local", ast::StateSpace::Local => "local",
ast::StateSpace::Param => "param", ast::StateSpace::Param => "param",
ast::StateSpace::Sreg => "sreg",
ast::StateSpace::SharedCluster => "shared_cluster", ast::StateSpace::SharedCluster => "shared_cluster",
ast::StateSpace::ParamEntry => "param_entry", ast::StateSpace::ParamEntry => "param_entry",
ast::StateSpace::SharedCta => "shared_cta", ast::StateSpace::SharedCta => "shared_cta",

19
ptx/src/pass/insert_implicit_conversions.rs
View file

@ -128,7 +128,7 @@ pub(crate) fn default_implicit_conversion(
(instruction_space, instruction_type): (ast::StateSpace, &ast::Type), (instruction_space, instruction_type): (ast::StateSpace, &ast::Type),
) -> Result<Option<ConversionKind>, TranslateError> { ) -> Result<Option<ConversionKind>, TranslateError> {
if instruction_space == ast::StateSpace::Reg { if instruction_space == ast::StateSpace::Reg {
if space_is_compatible(operand_space, ast::StateSpace::Reg) { if operand_space == ast::StateSpace::Reg {
if let (ast::Type::Vector(vec_len, vec_underlying_type), ast::Type::Scalar(scalar)) = if let (ast::Type::Vector(vec_len, vec_underlying_type), ast::Type::Scalar(scalar)) =
(operand_type, instruction_type) (operand_type, instruction_type)
{ {
@ -142,7 +142,7 @@ pub(crate) fn default_implicit_conversion(
return Ok(Some(ConversionKind::AddressOf)); return Ok(Some(ConversionKind::AddressOf));
} }
} }
if !space_is_compatible(instruction_space, operand_space) { if instruction_space != operand_space {
default_implicit_conversion_space( default_implicit_conversion_space(
(operand_space, operand_type), (operand_space, operand_type),
(instruction_space, instruction_type), (instruction_space, instruction_type),
@ -161,7 +161,7 @@ fn is_addressable(this: ast::StateSpace) -> bool {
| ast::StateSpace::Global | ast::StateSpace::Global
| ast::StateSpace::Local | ast::StateSpace::Local
| ast::StateSpace::Shared => true, | ast::StateSpace::Shared => true,
ast::StateSpace::Param | ast::StateSpace::Reg | ast::StateSpace::Sreg => false, ast::StateSpace::Param | ast::StateSpace::Reg => false,
ast::StateSpace::SharedCluster ast::StateSpace::SharedCluster
| ast::StateSpace::SharedCta | ast::StateSpace::SharedCta
| ast::StateSpace::ParamEntry | ast::StateSpace::ParamEntry
@ -178,7 +178,7 @@ fn default_implicit_conversion_space(
|| (operand_space == ast::StateSpace::Generic && coerces_to_generic(instruction_space)) || (operand_space == ast::StateSpace::Generic && coerces_to_generic(instruction_space))
{ {
Ok(Some(ConversionKind::PtrToPtr)) Ok(Some(ConversionKind::PtrToPtr))
} else if space_is_compatible(operand_space, ast::StateSpace::Reg) { } else if operand_space == ast::StateSpace::Reg {
match operand_type { match operand_type {
ast::Type::Pointer(operand_ptr_type, operand_ptr_space) ast::Type::Pointer(operand_ptr_type, operand_ptr_space)
if *operand_ptr_space == instruction_space => if *operand_ptr_space == instruction_space =>
@ -210,7 +210,7 @@ fn default_implicit_conversion_space(
}, },
_ => Err(error_mismatched_type()), _ => Err(error_mismatched_type()),
} }
} else if space_is_compatible(instruction_space, ast::StateSpace::Reg) { } else if instruction_space == ast::StateSpace::Reg {
match instruction_type { match instruction_type {
ast::Type::Pointer(instruction_ptr_type, instruction_ptr_space) ast::Type::Pointer(instruction_ptr_type, instruction_ptr_space)
if operand_space == *instruction_ptr_space => if operand_space == *instruction_ptr_space =>
@ -234,7 +234,7 @@ fn default_implicit_conversion_type(
operand_type: &ast::Type, operand_type: &ast::Type,
instruction_type: &ast::Type, instruction_type: &ast::Type,
) -> Result<Option<ConversionKind>, TranslateError> { ) -> Result<Option<ConversionKind>, TranslateError> {
if space_is_compatible(space, ast::StateSpace::Reg) { if space == ast::StateSpace::Reg {
if should_bitcast(instruction_type, operand_type) { if should_bitcast(instruction_type, operand_type) {
Ok(Some(ConversionKind::Default)) Ok(Some(ConversionKind::Default))
} else { } else {
@ -257,8 +257,7 @@ fn coerces_to_generic(this: ast::StateSpace) -> bool {
| ast::StateSpace::Param | ast::StateSpace::Param
| ast::StateSpace::ParamEntry | ast::StateSpace::ParamEntry
| ast::StateSpace::ParamFunc | ast::StateSpace::ParamFunc
| ast::StateSpace::Generic | ast::StateSpace::Generic => false,
| ast::StateSpace::Sreg => false,
} }
} }
@ -294,7 +293,7 @@ pub(crate) fn should_convert_relaxed_dst_wrapper(
(operand_space, operand_type): (ast::StateSpace, &ast::Type), (operand_space, operand_type): (ast::StateSpace, &ast::Type),
(instruction_space, instruction_type): (ast::StateSpace, &ast::Type), (instruction_space, instruction_type): (ast::StateSpace, &ast::Type),
) -> Result<Option<ConversionKind>, TranslateError> { ) -> Result<Option<ConversionKind>, TranslateError> {
if !space_is_compatible(operand_space, instruction_space) { if operand_space != instruction_space {
return Err(TranslateError::MismatchedType); return Err(TranslateError::MismatchedType);
} }
if operand_type == instruction_type { if operand_type == instruction_type {
@ -371,7 +370,7 @@ pub(crate) fn should_convert_relaxed_src_wrapper(
(operand_space, operand_type): (ast::StateSpace, &ast::Type), (operand_space, operand_type): (ast::StateSpace, &ast::Type),
(instruction_space, instruction_type): (ast::StateSpace, &ast::Type), (instruction_space, instruction_type): (ast::StateSpace, &ast::Type),
) -> Result<Option<ConversionKind>, TranslateError> { ) -> Result<Option<ConversionKind>, TranslateError> {
if !space_is_compatible(operand_space, instruction_space) { if operand_space != instruction_space {
return Err(error_mismatched_type()); return Err(error_mismatched_type());
} }
if operand_type == instruction_type { if operand_type == instruction_type {

2
ptx/src/pass/insert_mem_ssa_statements.rs
View file

@ -189,7 +189,7 @@ impl<'a, 'input> InsertMemSSAVisitor<'a, 'input> {
return Ok(symbol); return Ok(symbol);
}; };
let (mut var_type, var_space, is_variable) = self.id_def.get_typed(symbol)?; let (mut var_type, var_space, is_variable) = self.id_def.get_typed(symbol)?;
if !space_is_compatible(var_space, ast::StateSpace::Reg) || !is_variable { if var_space != ast::StateSpace::Reg || !is_variable {
return Ok(symbol); return Ok(symbol);
}; };
let member_index = match member_index { let member_index = match member_index {

8
ptx/src/pass/mod.rs
View file

@ -525,7 +525,7 @@ impl<'b> NumericIdResolver<'b> {
Some(Some(x)) => Ok(x.clone()), Some(Some(x)) => Ok(x.clone()),
Some(None) => Err(TranslateError::UntypedSymbol), Some(None) => Err(TranslateError::UntypedSymbol),
None => match self.special_registers.get(id) { None => match self.special_registers.get(id) {
Some(x) => Ok((x.get_type(), ast::StateSpace::Sreg, true)), Some(x) => Ok((x.get_type(), ast::StateSpace::Reg, true)),
None => match self.global_type_check.get(&id) { None => match self.global_type_check.get(&id) {
Some(Some(result)) => Ok(result.clone()), Some(Some(result)) => Ok(result.clone()),
Some(None) | None => Err(TranslateError::UntypedSymbol), Some(None) | None => Err(TranslateError::UntypedSymbol),
@ -1207,12 +1207,6 @@ impl<
} }
} }
fn space_is_compatible(this: ast::StateSpace, other: ast::StateSpace) -> bool {
this == other
|| this == ast::StateSpace::Reg && other == ast::StateSpace::Sreg
|| this == ast::StateSpace::Sreg && other == ast::StateSpace::Reg
}
fn register_external_fn_call<'a>( fn register_external_fn_call<'a>(
id_defs: &mut NumericIdResolver, id_defs: &mut NumericIdResolver,
ptx_impl_imports: &mut HashMap<String, Directive>, ptx_impl_imports: &mut HashMap<String, Directive>,

1
ptx_parser/src/lib.rs
View file

@ -1499,7 +1499,6 @@ derive_parser!(
pub enum StateSpace { pub enum StateSpace {
Reg, Reg,
Generic, Generic,
Sreg,
} }
#[derive(Copy, Clone, PartialEq, Eq, Hash)] #[derive(Copy, Clone, PartialEq, Eq, Hash)]