From e3fe0319467546bae070137c58dcf8f9fbe93c79 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Thu, 19 Dec 2019 11:23:14 -0500 Subject: WIP CUDA source emit (#1157) * CPPCompiler -> DownstreamCompiler * Added DownstreamCompileResult to start abstraction such that we don't need files. * * Split out slang-blob.cpp * Made CompileResult hold a DownstreamCompileResult - for access to binary or ISlangSharedLibrary * Keep temporary files in scope. * Add a hash to the hex dump stream. * Move all file tracking into DownstreamCompiler. * WIP support for nvrtc. * WIP: Adding support for nvrtc compiler. Adding enum types, wiring up the nvrtc into slang. * Fix remaining CPPCompiler references. * Fix order issue on target string matching. * Use ISlangSharedLibrary for nvrtc. * Use DownstreamCompiler for nvrtc. * WIP first pass at compilation win nvrtc. * Added testing if file is on file system into CommandLineDownstreamCompiler. Added sourceContentsPath. * Make test cuda-compile.cu work by just compiling not comparing output. * Genearlize DownstreamCompiler usage. * Fix warning on clang. * Remove CompilerType from DownstreamCompiler. * Use DownstreamCompiler interface for all compilers. NOTE for FXC, DXC and GLSLANG this doesn't mean using 'compile' - it's still extracting functions from shared library. * Replace DownstreamCompiler::SourceType -> SlangSourceLanguage * Replace _canCompile with something data driven. * Fix compiling on gcc/clang for DownstreamCompiler. * Moved some text conversions into DownstreamCompiler. * Fix problem on non-vc builds with not having return on locateCompilers for VS. * Change so no warning for code not reachable on locateCompilers for vs. * WIP: CUDA code generation - currently just using CPU layout and HLSL. * emitXXXForEntryPoint -> emitEntryPointSource emitSourceForEntryPoint -> emitEntryPointSourceFromIR Fix up generating cuda to get PTX. * WIP emitting cuda for IR. * Small improvements to CUDA ouput. * Disable the CUDA emit test, as output not currently compilable. --- source/slang/slang-type-layout.cpp | 113 +++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) (limited to 'source/slang/slang-type-layout.cpp') diff --git a/source/slang/slang-type-layout.cpp b/source/slang/slang-type-layout.cpp index 88e62323b..772686163 100644 --- a/source/slang/slang-type-layout.cpp +++ b/source/slang/slang-type-layout.cpp @@ -398,6 +398,13 @@ struct CPULayoutRulesImpl : DefaultLayoutRulesImpl } }; +// TODO(JS): Most likely wrong. For layout for CUDA, we'll just do the default to get things up and running +struct CUDALayoutRulesImpl : DefaultLayoutRulesImpl +{ + typedef DefaultLayoutRulesImpl Super; +}; + + struct HLSLStructuredBufferLayoutRulesImpl : DefaultLayoutRulesImpl { // HLSL structured buffers drop the restrictions added for constant buffers, @@ -653,9 +660,29 @@ struct CPULayoutRulesFamilyImpl : LayoutRulesFamilyImpl LayoutRulesImpl* getStructuredBufferRules() override; }; +struct CUDALayoutRulesFamilyImpl : LayoutRulesFamilyImpl +{ + virtual LayoutRulesImpl* getConstantBufferRules() override; + virtual LayoutRulesImpl* getPushConstantBufferRules() override; + virtual LayoutRulesImpl* getTextureBufferRules() override; + virtual LayoutRulesImpl* getVaryingInputRules() override; + virtual LayoutRulesImpl* getVaryingOutputRules() override; + virtual LayoutRulesImpl* getSpecializationConstantRules() override; + virtual LayoutRulesImpl* getShaderStorageBufferRules() override; + virtual LayoutRulesImpl* getParameterBlockRules() override; + + LayoutRulesImpl* getRayPayloadParameterRules() override; + LayoutRulesImpl* getCallablePayloadParameterRules() override; + LayoutRulesImpl* getHitAttributesParameterRules() override; + + LayoutRulesImpl* getShaderRecordConstantBufferRules() override; + LayoutRulesImpl* getStructuredBufferRules() override; +}; + GLSLLayoutRulesFamilyImpl kGLSLLayoutRulesFamilyImpl; HLSLLayoutRulesFamilyImpl kHLSLLayoutRulesFamilyImpl; CPULayoutRulesFamilyImpl kCPULayoutRulesFamilyImpl; +CUDALayoutRulesFamilyImpl kCUDALayoutRulesFamilyImpl; // CPU case @@ -703,6 +730,12 @@ struct CPUObjectLayoutRulesImpl : ObjectLayoutRulesImpl }; +// TODO(JS): Most likely wrong! Use CPU layout for CUDA for now +struct CUDAObjectLayoutRulesImpl : CPUObjectLayoutRulesImpl +{ + typedef CPUObjectLayoutRulesImpl Super; + +}; static CPUObjectLayoutRulesImpl kCPUObjectLayoutRulesImpl; static CPULayoutRulesImpl kCPULayoutRulesImpl; @@ -711,6 +744,16 @@ LayoutRulesImpl kCPULayoutRulesImpl_ = { &kCPULayoutRulesFamilyImpl, &kCPULayoutRulesImpl, &kCPUObjectLayoutRulesImpl, }; +// CUDA + +static CUDAObjectLayoutRulesImpl kCUDAObjectLayoutRulesImpl; +static CUDALayoutRulesImpl kCUALayoutRulesImpl; + +LayoutRulesImpl kCUDALayoutRulesImpl_ = { + &kCPULayoutRulesFamilyImpl, &kCUALayoutRulesImpl, &kCUDAObjectLayoutRulesImpl, +}; + + // GLSL cases LayoutRulesImpl kStd140LayoutRulesImpl_ = { @@ -986,6 +1029,69 @@ LayoutRulesImpl* CPULayoutRulesFamilyImpl::getStructuredBufferRules() return &kCPULayoutRulesImpl_; } +// CUDA Family + +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getConstantBufferRules() +{ + return &kCPULayoutRulesImpl_; +} + +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getPushConstantBufferRules() +{ + return &kCPULayoutRulesImpl_; +} + +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getTextureBufferRules() +{ + return nullptr; +} + +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getVaryingInputRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getVaryingOutputRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getSpecializationConstantRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getShaderStorageBufferRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getParameterBlockRules() +{ + // Not clear - just use similar to CPU + return &kCUDALayoutRulesImpl_; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getRayPayloadParameterRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getCallablePayloadParameterRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getHitAttributesParameterRules() +{ + return nullptr; +} +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getShaderRecordConstantBufferRules() +{ + // Just following HLSLs lead for the moment + return &kCUDALayoutRulesImpl_; +} + +LayoutRulesImpl* CUDALayoutRulesFamilyImpl::getStructuredBufferRules() +{ + return &kCUDALayoutRulesImpl_; +} + + + LayoutRulesFamilyImpl* getDefaultLayoutRulesFamilyForTarget(TargetRequest* targetReq) { switch (targetReq->getTarget()) @@ -1019,6 +1125,13 @@ LayoutRulesFamilyImpl* getDefaultLayoutRulesFamilyForTarget(TargetRequest* targe return &kCPULayoutRulesFamilyImpl; } + case CodeGenTarget::PTX: + case CodeGenTarget::CUDASource: + { + return &kCUDALayoutRulesFamilyImpl; + } + + default: return nullptr; } -- cgit v1.2.3