From 0ca14d740fcf76579d17f5b573f3f003f04592bc Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Mon, 13 Dec 2021 22:25:26 +0100 Subject: [PATCH] Better reporting of unrecognized tokens --- hip_runtime-sys/build.rs | 18 +- hip_runtime-sys/lib/amdhip64.def | 308 +++++++++++++++++++++++++++++++ hip_runtime-sys/lib/amdhip64.lib | Bin 0 -> 71480 bytes ptx/src/lib.rs | 112 +++++++++++ ptx/src/ptx.lalrpop | 11 +- zluda_dump/src/trace.rs | 39 ++-- 6 files changed, 461 insertions(+), 27 deletions(-) create mode 100644 hip_runtime-sys/lib/amdhip64.def create mode 100644 hip_runtime-sys/lib/amdhip64.lib diff --git a/hip_runtime-sys/build.rs b/hip_runtime-sys/build.rs index 9c3d9b4..3bc1250 100644 --- a/hip_runtime-sys/build.rs +++ b/hip_runtime-sys/build.rs @@ -1,9 +1,21 @@ use std::env::VarError; +use std::{env, path::PathBuf}; fn main() -> Result<(), VarError> { println!("cargo:rustc-link-lib=dylib=amdhip64"); - //println!("cargo:rustc-link-search=native=/opt/rocm/lib/"); - println!("cargo:rustc-link-search=native=/home/ubuntu/hipamd/build/lib"); - println!("cargo:rustc-link-search=native=/home/vosen/hipamd/build/lib"); + if cfg!(windows) { + let env = env::var("CARGO_CFG_TARGET_ENV")?; + if env == "msvc" { + let mut path = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?); + path.push("lib"); + println!("cargo:rustc-link-search=native={}", path.display()); + } else { + println!("cargo:rustc-link-search=native=C:\\Windows\\System32"); + }; + } else { + //println!("cargo:rustc-link-search=native=/opt/rocm/lib/"); + println!("cargo:rustc-link-search=native=/home/ubuntu/hipamd/build/lib"); + println!("cargo:rustc-link-search=native=/home/vosen/hipamd/build/lib"); + } Ok(()) } diff --git a/hip_runtime-sys/lib/amdhip64.def b/hip_runtime-sys/lib/amdhip64.def new file mode 100644 index 0000000..515d5c6 --- /dev/null +++ b/hip_runtime-sys/lib/amdhip64.def @@ -0,0 +1,308 @@ +LIBRARY AMDHIP64 +EXPORTS +__hipPopCallConfiguration +__hipPushCallConfiguration +__hipRegisterFatBinary +__hipRegisterFunction +__hipRegisterManagedVar +__hipRegisterSurface +__hipRegisterTexture +__hipRegisterVar +__hipUnregisterFatBinary +hipApiName +hipArray3DCreate +hipArrayCreate +hipArrayDestroy +hipBindTexture +hipBindTexture2D +hipBindTextureToArray +hipBindTextureToMipmappedArray +hipChooseDevice +hipConfigureCall +hipCreateChannelDesc +hipCreateSurfaceObject +hipCreateTextureObject +hipCtxCreate +hipCtxDestroy +hipCtxDisablePeerAccess +hipCtxEnablePeerAccess +hipCtxGetApiVersion +hipCtxGetCacheConfig +hipCtxGetCurrent +hipCtxGetDevice +hipCtxGetFlags +hipCtxGetSharedMemConfig +hipCtxPopCurrent +hipCtxPushCurrent +hipCtxSetCacheConfig +hipCtxSetCurrent +hipCtxSetSharedMemConfig +hipCtxSynchronize +hipDestroyExternalMemory +hipDestroyExternalSemaphore +hipDestroySurfaceObject +hipDestroyTextureObject +hipDeviceCanAccessPeer +hipDeviceComputeCapability +hipDeviceDisablePeerAccess +hipDeviceEnablePeerAccess +hipDeviceGet +hipDeviceGetAttribute +hipDeviceGetByPCIBusId +hipDeviceGetCacheConfig +hipDeviceGetLimit +hipDeviceGetName +hipDeviceGetP2PAttribute +hipDeviceGetPCIBusId +hipDeviceGetSharedMemConfig +hipDeviceGetStreamPriorityRange +hipDevicePrimaryCtxGetState +hipDevicePrimaryCtxRelease +hipDevicePrimaryCtxReset +hipDevicePrimaryCtxRetain +hipDevicePrimaryCtxSetFlags +hipDeviceReset +hipDeviceSetCacheConfig +hipDeviceSetSharedMemConfig +hipDeviceSynchronize +hipDeviceTotalMem +hipDriverGetVersion +hipDrvMemcpy2DUnaligned +hipDrvMemcpy3D +hipDrvMemcpy3DAsync +hipEnableActivityCallback +hipEventCreate +hipEventCreateWithFlags +hipEventDestroy +hipEventElapsedTime +hipEventQuery +hipEventRecord +hipEventSynchronize +hipExtGetLinkTypeAndHopCount +hipExtLaunchKernel +hipExtLaunchMultiKernelMultiDevice +hipExtMallocWithFlags +hipExtModuleLaunchKernel +hipExtStreamCreateWithCUMask +hipExtStreamGetCUMask +hipExternalMemoryGetMappedBuffer +hipFree +hipFreeArray +hipFreeHost +hipFreeMipmappedArray +hipFuncGetAttribute +hipFuncGetAttributes +hipFuncSetAttribute +hipFuncSetCacheConfig +hipFuncSetSharedMemConfig +hipGLGetDevices +hipGetChannelDesc +hipGetCmdName +hipGetDevice +hipGetDeviceCount +hipGetDeviceFlags +hipGetDeviceProperties +hipGetErrorName +hipGetErrorString +hipGetLastError +hipGetMipmappedArrayLevel +hipGetSymbolAddress +hipGetSymbolSize +hipGetTextureAlignmentOffset +hipGetTextureObjectResourceDesc +hipGetTextureObjectResourceViewDesc +hipGetTextureObjectTextureDesc +hipGetTextureReference +hipGraphAddDependencies +hipGraphAddEmptyNode +hipGraphAddKernelNode +hipGraphAddMemcpyNode +hipGraphAddMemcpyNode1D +hipGraphAddMemsetNode +hipGraphCreate +hipGraphDestroy +hipGraphExecDestroy +hipGraphExecKernelNodeSetParams +hipGraphGetNodes +hipGraphGetRootNodes +hipGraphInstantiate +hipGraphKernelNodeGetParams +hipGraphKernelNodeSetParams +hipGraphLaunch +hipGraphMemcpyNodeGetParams +hipGraphMemcpyNodeSetParams +hipGraphMemsetNodeGetParams +hipGraphMemsetNodeSetParams +hipGraphicsGLRegisterBuffer +hipGraphicsMapResources +hipGraphicsResourceGetMappedPointer +hipGraphicsUnmapResources +hipGraphicsUnregisterResource +hipHccModuleLaunchKernel +hipHostAlloc +hipHostFree +hipHostGetDevicePointer +hipHostGetFlags +hipHostMalloc +hipHostRegister +hipHostUnregister +hipImportExternalMemory +hipImportExternalSemaphore +hipInit +hipInitActivityCallback +hipIpcCloseMemHandle +hipIpcGetEventHandle +hipIpcGetMemHandle +hipIpcOpenEventHandle +hipIpcOpenMemHandle +hipKernelNameRef +hipLaunchByPtr +hipLaunchCooperativeKernel +hipLaunchCooperativeKernelMultiDevice +hipLaunchKernel +hipMalloc +hipMalloc3D +hipMalloc3DArray +hipMallocArray +hipMallocHost +hipMallocManaged +hipMallocMipmappedArray +hipMallocPitch +hipMemAdvise +hipMemAllocHost +hipMemAllocPitch +hipMemGetAddressRange +hipMemGetInfo +hipMemPrefetchAsync +hipMemPtrGetInfo +hipMemRangeGetAttribute +hipMemRangeGetAttributes +hipMemcpy +hipMemcpy2D +hipMemcpy2DAsync +hipMemcpy2DFromArray +hipMemcpy2DFromArrayAsync +hipMemcpy2DToArray +hipMemcpy2DToArrayAsync +hipMemcpy3D +hipMemcpy3DAsync +hipMemcpyAsync +hipMemcpyAtoH +hipMemcpyDtoD +hipMemcpyDtoDAsync +hipMemcpyDtoH +hipMemcpyDtoHAsync +hipMemcpyFromArray +hipMemcpyFromSymbol +hipMemcpyFromSymbolAsync +hipMemcpyHtoA +hipMemcpyHtoD +hipMemcpyHtoDAsync +hipMemcpyParam2D +hipMemcpyParam2DAsync +hipMemcpyPeer +hipMemcpyPeerAsync +hipMemcpyToArray +hipMemcpyToSymbol +hipMemcpyToSymbolAsync +hipMemcpyWithStream +hipMemset +hipMemset2D +hipMemset2DAsync +hipMemset3D +hipMemset3DAsync +hipMemsetAsync +hipMemsetD16 +hipMemsetD16Async +hipMemsetD32 +hipMemsetD32Async +hipMemsetD8 +hipMemsetD8Async +hipMipmappedArrayCreate +hipMipmappedArrayDestroy +hipMipmappedArrayGetLevel +hipModuleGetFunction +hipModuleGetGlobal +hipModuleGetTexRef +hipModuleLaunchKernel +hipModuleLaunchKernelExt +hipModuleLoad +hipModuleLoadData +hipModuleLoadDataEx +hipModuleOccupancyMaxActiveBlocksPerMultiprocessor +hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags +hipModuleOccupancyMaxPotentialBlockSize +hipModuleOccupancyMaxPotentialBlockSizeWithFlags +hipModuleUnload +hipOccupancyMaxActiveBlocksPerMultiprocessor +hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags +hipOccupancyMaxPotentialBlockSize +hipPeekAtLastError +hipPointerGetAttributes +hipProfilerStart +hipProfilerStop +hipRegisterActivityCallback +hipRegisterApiCallback +hipRemoveActivityCallback +hipRemoveApiCallback +hipRuntimeGetVersion +hipSetDevice +hipSetDeviceFlags +hipSetupArgument +hipSignalExternalSemaphoresAsync +hipStreamAddCallback +hipStreamAttachMemAsync +hipStreamBeginCapture +hipStreamCreate +hipStreamCreateWithFlags +hipStreamCreateWithPriority +hipStreamDestroy +hipStreamEndCapture +hipStreamGetFlags +hipStreamGetPriority +hipStreamIsCapturing +hipStreamQuery +hipStreamSynchronize +hipStreamWaitEvent +hipTexObjectCreate +hipTexObjectDestroy +hipTexObjectGetResourceDesc +hipTexObjectGetResourceViewDesc +hipTexObjectGetTextureDesc +hipTexRefGetAddress +hipTexRefGetAddressMode +hipTexRefGetArray +hipTexRefGetBorderColor +hipTexRefGetFilterMode +hipTexRefGetFlags +hipTexRefGetFormat +hipTexRefGetMaxAnisotropy +hipTexRefGetMipmapFilterMode +hipTexRefGetMipmapLevelBias +hipTexRefGetMipmapLevelClamp +hipTexRefGetMipmappedArray +hipTexRefSetAddress +hipTexRefSetAddress2D +hipTexRefSetAddressMode +hipTexRefSetArray +hipTexRefSetBorderColor +hipTexRefSetFilterMode +hipTexRefSetFlags +hipTexRefSetFormat +hipTexRefSetMaxAnisotropy +hipTexRefSetMipmapFilterMode +hipTexRefSetMipmapLevelBias +hipTexRefSetMipmapLevelClamp +hipTexRefSetMipmappedArray +hipUnbindTexture +hipWaitExternalSemaphoresAsync +hiprtcAddNameExpression +hiprtcCompileProgram +hiprtcCreateProgram +hiprtcDestroyProgram +hiprtcGetCode +hiprtcGetCodeSize +hiprtcGetErrorString +hiprtcGetLoweredName +hiprtcGetProgramLog +hiprtcGetProgramLogSize diff --git a/hip_runtime-sys/lib/amdhip64.lib b/hip_runtime-sys/lib/amdhip64.lib new file mode 100644 index 0000000000000000000000000000000000000000..1d7df961e35d5ae012398e42d2e2b286facdfc58 GIT binary patch literal 71480 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 YI+r8r*3w^Z*Vc6EEO}lWF;bWR2YLVQV*mgE literal 0 HcmV?d00001 diff --git a/ptx/src/lib.rs b/ptx/src/lib.rs index 4ade4e8..db9fc23 100644 --- a/ptx/src/lib.rs +++ b/ptx/src/lib.rs @@ -28,6 +28,8 @@ pub mod ast; mod test; mod translate; +use std::fmt; + pub use crate::ptx::ModuleParser; pub use lalrpop_util::lexer::Token; pub use lalrpop_util::ParseError; @@ -36,6 +38,86 @@ pub use translate::to_spirv_module; pub use translate::KernelInfo; pub use translate::TranslateError; +pub trait ModuleParserExt { + fn parse_checked<'input>( + txt: &'input str, + ) -> Result, Vec, ast::PtxError>>>; + + // Returned AST might be malformed. Some users, like logger, want to look at + // malformed AST to record information - list of kernels or such + fn parse_unchecked<'input>( + txt: &'input str, + ) -> ( + ast::Module<'input>, + Vec, ast::PtxError>>, + ); +} + +impl ModuleParserExt for ModuleParser { + fn parse_checked<'input>( + txt: &'input str, + ) -> Result, Vec, ast::PtxError>>> { + let mut errors = Vec::new(); + let maybe_ast = ptx::ModuleParser::new().parse(&mut errors, txt); + match (&*errors, maybe_ast) { + (&[], Ok(ast)) => Ok(ast), + (_, Err(unrecoverable)) => { + errors.push(unrecoverable); + Err(errors) + } + (_, Ok(_)) => Err(errors), + } + } + + fn parse_unchecked<'input>( + txt: &'input str, + ) -> ( + ast::Module<'input>, + Vec, ast::PtxError>>, + ) { + let mut errors = Vec::new(); + let maybe_ast = ptx::ModuleParser::new().parse(&mut errors, txt); + let ast = match maybe_ast { + Ok(ast) => ast, + Err(unrecoverable_err) => { + errors.push(unrecoverable_err); + ast::Module { + version: (0, 0), + directives: Vec::new(), + } + } + }; + (ast, errors) + } +} + +pub struct DisplayParseError<'a, Loc, Tok, Err>(pub &'a str, pub &'a ParseError); + +impl<'a, Loc, Tok, Err> fmt::Display for DisplayParseError<'a, Loc, Tok, Err> +where + Loc: fmt::Display + Into + Copy, + Tok: fmt::Display, + Err: fmt::Display, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.1 { + ParseError::UnrecognizedToken { + token: (start, token, end), + .. + } => { + let full_instruction = + unsafe { self.0.get_unchecked((*start).into()..(*end).into()) }; + write!( + f, + "`{}` unrecognized token `{}` found at {}:{}", + full_instruction, token, start, end + ) + } + _ => self.fmt(f), + } + } +} + pub(crate) fn without_none(x: Vec>) -> Vec { x.into_iter().filter_map(|x| x).collect() } @@ -53,3 +135,33 @@ pub(crate) fn vector_index<'input>( }), } } + +#[cfg(test)] +mod tests { + use crate::{DisplayParseError, ModuleParser, ModuleParserExt}; + + #[test] + fn error_report_unknown_instructions() { + let module = r#" + .version 6.5 + .target sm_30 + .address_size 64 + + .visible .entry add( + .param .u64 input, + ) + { + .reg .u64 x; + does_not_exist.u64 x, x; + ret; + }"#; + let errors = match ModuleParser::parse_checked(module) { + Err(e) => e, + Ok(_) => panic!(), + }; + assert_eq!(errors.len(), 1); + let reporter = DisplayParseError(module, &errors[0]); + let build_log_string = format!("{}", reporter); + assert!(build_log_string.contains("does_not_exist")); + } +} diff --git a/ptx/src/ptx.lalrpop b/ptx/src/ptx.lalrpop index 181a727..f6fd9cd 100644 --- a/ptx/src/ptx.lalrpop +++ b/ptx/src/ptx.lalrpop @@ -526,8 +526,15 @@ Statement: Option>> = { ";" => Some(ast::Statement::Instruction(p, i)), PragmaStatement => None, "{" "}" => Some(ast::Statement::Block(without_none(s))), - ! ";" => { - let (err, _) = (<>); + @L ! ";" @R => { + let (start, mut err, _, end) = (<>); + // TODO: report this error more generally, perhaps in user error? + err.error = match err.error { + ParseError::UnrecognizedToken { token: (_, token, _), expected } => { + ParseError::UnrecognizedToken { token: (start, token, end), expected } + } + e => e + }; errors.push(err.error); None } diff --git a/zluda_dump/src/trace.rs b/zluda_dump/src/trace.rs index 3bdf807..eac6bbd 100644 --- a/zluda_dump/src/trace.rs +++ b/zluda_dump/src/trace.rs @@ -1,4 +1,5 @@ use ptx::{ast::PtxError, Token}; +use ptx::{DisplayParseError, ModuleParserExt}; use crate::{cuda::CUmodule, dark_api, log, Settings}; use std::{ @@ -170,24 +171,18 @@ impl StateTracker { submodule_index: Option, module_text: &str, ) { - let mut errors = Vec::new(); - let ast = ptx::ModuleParser::new().parse(&mut errors, module_text); - let ast = match (&*errors, ast) { - (&[], Ok(ast)) => ast, - (err_vec, res) => { - fn_logger.log(log::LogEntry::ModuleParsingError( - DumpWriter::get_file_name(module_index, version, submodule_index, "log"), - )); - fn_logger.log_io_error(self.writer.save_module_error_log( - module_index, - version, - submodule_index, - err_vec, - res.err(), - )); - return; - } - }; + let (ast, errors) = ptx::ModuleParser::parse_unchecked(module_text); + if !errors.is_empty() { + fn_logger.log(log::LogEntry::ModuleParsingError( + DumpWriter::get_file_name(module_index, version, submodule_index, "log"), + )); + fn_logger.log_io_error(self.writer.save_module_error_log( + module_index, + version, + submodule_index, + &*errors, + )); + } } pub(crate) fn module_exists(&self, hmod: CUmodule) -> bool { @@ -238,8 +233,7 @@ impl DumpWriter { module_index: usize, version: Option, submodule_index: Option, - recoverable: &[ptx::ParseError, PtxError>], - unrecoverable: Option, PtxError>>, + errors: &[ptx::ParseError, PtxError>], ) -> io::Result<()> { let mut log_file = match &self.dump_dir { None => return Ok(()), @@ -252,8 +246,9 @@ impl DumpWriter { "log", )); let mut file = File::create(log_file)?; - for error in unrecoverable.iter().chain(recoverable.iter()) { - writeln!(file, "{}", error)?; + for error in errors { + let pretty_print_error = DisplayParseError("", error); + writeln!(file, "{}", pretty_print_error)?; } Ok(()) }