| Age | Commit message (Collapse) | Author |
|---|
|
* Move the file public header files to `include` dir
Close the issue (#4635).
Move the following headers files to a `include` dir
located at root dir of slang repo:
slang-com-helper.h -> include/slang-com-helper.h
slang-com-ptr.h -> include/slang-com-ptr.h
slang-gfx.h -> include/slang-gfx.h
slang.h -> include/slang.h
Change cmake/SlangTarget.cmake to add include path to
every target, and change the source file to use
"#include <slang.h>" to include the public headers.
The source code update is by the script like follow:
```
fileNames_slang=$(grep -r "\".*slang\.h\"" source/ -l)
for fileName in "${fileNames_slang[@]}"
do
echo "$fileName"
sed -i "s/\".*slang\.h\"/\"slang\.h\"/" $fileName
done
```
* Fix the test issues
* Fix cpu test issues by adding include seach path
* Update cmake to not add include path for every target
Also change "#include <slang.h>" to "include "slang.h" " to
make the coding style consistent with other slang code.
* Change public include to private include for unit-test and slang-glslang
|
|
* Treat global variables and parameters as non-differentiable when checking derivative data-flow
Global parameters are by-default not differentiable (even if they are of a differentiable type), because our auto-diff passes do not touch anything outside of function bodies.
The solution is to use wrapper objects with differentiable getter/setter methods (and we should provide a few such objects in the stdlib).
Fixes: #3289
This is a potentially breaking change: User code that was previously working with global variables of a differentiable type will now throw an error (previously the gradient would be dropped without warning). The solution is to use `detach()` to keep same behavior as before or rewrite the access using differentiable getter/setter methods.
* Fix issues with lookup witness lowering
* Update slang-ir-lower-witness-lookup.cpp
* Add tests
* Update slang-ir-lower-witness-lookup.cpp
* Cleanup
* Update nested-assoc-types.slang
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
This extends the code for handling uninitialized output parameters.
Still needs to handle generic templates and assignment of uninitialized
values more carefully.
The file containing the relevant code are now in
source/slang/slang-ir-use-uninitialized-values.cpp
rather than the previous
source/slang/slang-ir-use-uninitialized-out-param.h
and the top-level function is now checkForUsingUinitializedValues.
Additionally a rudimentary test shader has been added for this case, which replaces the old file for out params only; tests/diagnositcs/uninitialized-out.slang becomes tests/diagnositcs/uninitialized.slang.
What this does not implement (could be future PRs):
* Checking uninitialized fields within constructors
* Partially uninitialized values with respect to data structure (e.g. arrays/structs/vector types)
* Partially uninitialized values with respect to control flow (e.g. if/else/loop)
|
|
`SubpassInput<T>` (#4462)
* Add case to `emitVectorReshape` for `vector<>` type, `scalar` value
1. Add new case
2. Add test
* fix warning
* fix warning
* Implement HLSL resource bindings and default type `float4` to `SubpassInput<T>`
fixes: #4440
1. Removed GLSLInputAttachmentIndexLayout modifier and the somewhat 'hacky' binding model 'Input Attachment' previously relied upon. This was changed to work with the slang-type-layout rules system. This change allows Slang automatic bindings, HLSL bindings, GLSL bindings, and translation of GLSL to and from HLSL bindings to work.
2. Added default argument `float4` to SubpassInput<T>.
3. Merged glsl.meta and hlsl.meta SubpassInput logic.
* fix InputAttachment attribute checks
fix InputAttachment attribute checks for HLSL and GLSL syntax
* remove unused var
* validate attribute correctly
Attributes do not have type information. We must check the type expression to validate attribute usage.
* remove hacky validation
type based validation before types are fully resolved is quite hacky and unstable to changes and wrapped types
* fix warning
* remove redundant `!= nullptr`
* remove extra `!= nullptr`
* fix some warnings/errors
* subpass capability to limit to dxc & remove default values in some functions
* revert logic to previous logic
revert logic to return if we have a binding regardless of if a VarDecl is given the binding
|
|
non-CUDA/Torch targets (#4364)
* Remove `IRHLSLExportDecoration` and `IRKeepAliveDecoration` for non-CUDA/Torch targets
* Update hlsl-torch-cross-compile.slang
|
|
* capability upgrade warning/error
adjusted implementation + tests to support a warning/error if capabilities are implicitly upgraded and test accordingly.
* add glsl profile caps
* add GLSL and HLSL capabilities to the associated capability
* syntax error in capdef
* only error if user explicitly enables capabilities
1. changed testing infrastructure to not set a `profile` explicitly,
2. Added tests to be sure this works as intended with user API and with slangc command line
* Change capability atom definitions and how Slang manages them to fix errors
1. most `glsl_spirv` version atoms have been removed from `.capdef`, instead we will translate `spirv` version atoms into `glsl_spirv` since there is no point in writing the same code twice in `.capdef` files to define `spirv` versions.
2. add spirv version, and hlsl sm version (and equivlent) capability dependencies
3. removed some stage requirments which were set on objects, keep the wrapper capabilities. I am keeping the wrapper capabilities since I am unaware on if there are stage limitations (spec says code in practice does not work).
* check internal version instead of version profile (_spirv_1_5 vs. spirv_1_5)
* remove unused OpCapability. adjust SPIRV version'ing again for glsl_spirv
* apply workaround for glslang bug with rayquery usage
* ensure capabilities targetted by a profile and added together by a user are valid
* remove additions to `spirv_1_*` wrapper
* spirv_* -> glsl_spirv fix
* fix bug where incompatable profiles would cause invalid target caps
* try to avoid joining invalid capabilities
* fix the warning/error & printing
* run through tests to fix capability system and test mistakes
many mistakes were mesh shaders doing `-profile glsl_450+spirv_1_4`. This is not allowed for a few reasons
1. the test tooling does not handle arguments the same as `slangc`
2. glsl_450 core profile does not support mesh shaders, nor does spirv_1_4. sm_6_5 does work in this senario
* set some sm_4_1 intrinsics to sm_4_0
* replace `GLSL_` defs with `glsl_`
* swap the unsupported render-test syntax for working syntax
* set d3d11/d3d12 profile defaults
this is required since sm version changes compiled code & behavior
* adjusted nvapi capabilities with atomics + d3d11 set to use sm_5_0 as per default
* cleanup
* address review
* incorrect styling
* change `bitscanForward` to work as intended on 32 bit targets
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Default (zero'd) values with `-zero-initialize` flag
Adds `-zero-initialize` flag to set values to a __default() expression if they are missing a initExpr.
* address review and ensure __default calls ctor + zero's fields.
1. We must keep zero-initialize in SemanticsDeclHeaderVisitor. This is done because else a ctor will be initialized before we can set struct fields to `__default`.
2. IRDefaultCtorDecoration was added to track default ctor's with parent struct.
3. ParentAggTypeModifier was added to track ChildOfStruct->IRType for sharing data such as with functions. This is required to ensure we associate a lowered function with a lowered struct type
* Removed decoration to track defaultCtor in favor of field.
This was done since decorations are checked for IR objects, storing auxillary info does not work here as a result if usable object.
* address some review comments
Since `IDefaultInitializable` is taking a considerabley larger amount of time than anticipated I am pushing some of the other fixes requested. I did not remove the "IRStruct storing a default Ctor" hack yet.
mostly renamed/adjusted tests to work as intended
added test to ensure we don't synthisize a junk `= 0` when not in `zero initialize` mode
removed member in favor of sharedContext+dictionary.
* a working but incorrect impl
* default init without any IR hacks (fully working aside from generic/containored-types)
* Finish zero init code
1. IDefaultInitializer interface was added. If conforming, your type may be zero-initialized. To Conform a `__init()` is required
2. `[OnlyAutoInitIfForced]` was added. This attribute states that a default initializer should only be implicitly called if forced by the compiler (`zero-initialize` for example). This allows types which implicitly/explicitly conform to IDefaultInitialize to have optional auto-init behavior (which is Slang's default for user structs) to be disabled.
* note about `[OnlyAutoInitIfForced]`. This is required for std-lib to not automatically resolve init-expressions for std-lib, but it has the added benifit of allowing user made structs/classes to control the default behavior of initializing
* fix ErrType assumption
* testing why dx12 fails local but passes CI
* push vector changes to generic test
* push syntax adjustment, still figuring out what is wrong with cuda.
* remove debug changes & adjust style
* fix field-init expressions with structs initializers
don't init a static in a ctor. This would be illegal code and wrong code (init list in lower-to-ir)
* minor adjustments temporarily while the rest of the issue is discussed
* fix
* implement IDefaultInitializable
* remove a unneeded whitespace change
* fix type checking error
should be checking if a valid type is `Type`, not `BasicExpressionType`
* needs to be DeclRefType, not Type
* fix langguage server error
* change findinheritance for correctness + cleanup
* remove return false
verified the issue was `findInheritance`
* push attempt at language server fix
* still trying to fix inheritance
* added extension support, remove redundant code
Did not address all review comments yet, want to see if CI also passes my changes
* undo a change which caused CI to fail
* change logic + DefaultConstructExpr
setup code to use defaultConstructExpr when possible to construct a default without overhead of invoke/related
also changed code so parent's defaultInitializable propegates to derived member
* 1. fix error in `isSubtype` 2. add flag to isSubtype
`subtypeInheritanceIsNotFullyResolved` was added since we may not be done the lookup stage but still require `isSubtype` checking to verify usage of inheritance while working with inheritance. In This case we will just skip `ensureLookup` and "caching" (since we don't have a cache invalidation system, nor need)
* fix bug in logic + add test to better catch the bug
* address comment + isSubTypeOption + wrapper type test,
* fix wrong code adjustment
I checked on the CI and realized I caused a failure, mistake was made not negating some code
* syntax, class naming capital
* remove stdlib default initialize changes, replace with `__default()` for init
* remove redundant code + fix defaultConstruct emitting
previously defaultConstruct emitting was crashing due to having generics unresolved. By not resolving the default construct immediately, everything works.
* remove a coment
* add test to ensure static variables dont `init` inside a struct's `__init`
* fix Ptr members breaking struct use
* address review and add -zero-initialize test
`-zero-initialize` test was added to be sure debug pointers are not broken with default init values
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Print warning when operator<< shifting too much
Closes #3944
For the given type of the left side operand to `operator<<` is not big
enough for the right side operand, print a warning that the result will
be always zero.
|
|
Add option "-disable-source-map" to disable the source map in obfuscation.
|
|
|
|
* Fix a bug on default initialization of interface typed value.
* Fix.
|
|
* Add options to speedup compilation.
* Fix.
* Plumb options to DCE pass.
* Revert debug change.
* Fix regressions.
* More optimizations.
* more cleanup and fixes.
* remove comment.
* Fixes.
* Another fix.
* Fix errors.
* Fix errors.
* Add comments.
|
|
* fix all Clang-14 warnings
* remove a clang-14 warning fix because it is a MSVC warning...
|
|
* Add diagnostic to prevent defining unsized static variables.
* Fix tests.
* Add more tests.
* Fix to allow defining variables of link-time size.
* update diagnostic message.
* Fix tests.
* Simplify code.
|
|
* Remove use of `G0` and `__target_intrinsic` in stdlib.
* Fix.
* Fix calling intrinsic in global scope.
|
|
* Fix race-condition and visual artifacts issues
In PerformanceProfiler::getProfiler() we return a static object
for the profiler implementation, this is not thread-safe, so change
it to thead_local.
There is still some visual artifacts when using slang as the shading
language. We don't know the root cause yet, but found out it's related
to our loop inversion algorithm. So stage this feature for now, and turn
it into an internal option and default off. We will re-enable it after
more investigation on this optimization.
File an new issue 4151 to track it.
* Add '-loop-inversion' to the few tests
|
|
Fixes #4112.
|
|
Fixes #4110.
|
|
* Fix `Ptr::__subscript` to accept any integer index.
* Fix `Ptr::__subscript` to allow 64bit indices.
|
|
|
|
* Force Inline if reftype
Fixes #3997.
If we are using a refType, we now ForceInline.
remarks:
1. Modifications were made in slang-ir-glsl-legalize to change how we translate GlobalParam proxy's into GlobalParam.
a. We now handle the senario where a globalParam is used in multiple disjoint blocks (like 2 different functions).
* try to figure out why CI fails but local works
try to inline DispatchMesh, works locally, may fail on CI(?)
* try another fix
* add task tests + don't allow semi-early task-shader inline
Task shader uses DispatchMesh which is a very big 'hack' where we check for the function name and modify the callees in very large ways. This function does inline, but it cannot inline early due to future mangling that this operation requires todo. This is reflected with the `[noRefInline]` modifier. It is a modifier so users may stop mandatory inlines with `__ref` parameter.
|
|
* Support derivative functions in compute & capabilities adjustments
fixes #4000
PR implements derivative functions in compute shaders properly so we have the functionality for SPIR-V & GLSL. Tests reflect fragment and compute paths.
PR also adjusts capabilities to correct wrong SPRI-V target capabilities for when using textures.
Remarks:
1. __requireComputeDerivative(); is a intrinsic_op and not modifier since inlining will destroy the modifier.
2. Derivative mode is tied to an entry point decoration `[DerivativeGroupQuad]`/`[DerivativeGroupLinear]` or GLSL syntax ``derivative_group_linearNV`. Default is to set the mode to `[DerivativeGroupQuad]`
* remove -emit-spirv-directly
* fixes
1. fix minor issue fwidth change where I returned the wrong type
2. fix issue where glslang{glsl->spirv} is wrong, so we don't run that test and just run the glsl test & direct spir-v test for intrinsic-texture.slang
* adjust as per review and refine code
1. add test to ensure multi-diverging-in-logic entry points work -- 2 functions which may cause computeDerivatives + 1 that uses, 1 that does not.
2. naming
3. use entry point ref graph for c-like-targets
4. reordered some code to util's and removed `static linline` since that was just for ease of coding on my end (should not have been pushed).
* Grammer
* split up source file + issolate GLSL emit path change.
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Switch to direct-to-spirv backend as default.
* Fix slang-test.
* Fix.
* Fix.
|
|
* Init expressions for struct members
Following commit handles init expressions of struct's.
The general implementation follows C++ init expression rules for classes & inherited classes.
The logic was implemented after type resolution (`SemanticsDeclAttributesVisitor`):
1. Create a default constructor if missing.
2. Check all member variables (`this` and `super`) for if a member has an init expression, continue to *3* if found.
3. For each constructor, insert a member variable's init expression at the beginning of a constructor. This is to follow how C++ does construction of objects.
Some important notes about implementation:
* We must handle the scenario that there is inheritance. To handle the inheritance information processing `findLevelsOfInheritance` was created.
* If a user manually sets overload rank's of constructor expression's we have no way to assume new default constructor overload ranks.
* address feedback
- moved all scope bound variables into if statment initializers
- added indent
- changed logic for overloadRank to be centered around positive numbers rather than negative
* Inheritance fixes universally & for struct field init
1. reimplemented struct field logic
2. implemented inheritance through calling a "super->init()" inisde a constructor for each "this".
3. implemented support for multi level inheritance (4+) and accessing members without a crash.
* add a way to ignore Forward declared constructors.
* a test and fix for a falcor failiure
the following case was not handled: creating an default Ctor due to a non L-Value struct field. Having an empty Ctor causes a warning.
* remove texture/sampler from test since it will break glsl
* get inheritance info using existing lookup logic
modified Facet lookups to store relative depth rather than arbitrary ::Self or' ::Direct for inheritance (which was 'wong' since depth 2 is not Direct, but was considered a Direct inheritance)
* cleanup unused
* cleanup unused functions and whitespace
* fix compile warning
* clean up, reorder, addressed language server fail
changed logic to safeguard bad code --> no longer breaks language server if code is incomplete.
remove the "semi-ordering" logic because caused a crash (and this code does nothing functionally, just thought it would be nice to add if '0 cost').
Remove rank setting for constructors, in place use an addition to the overload system: "this" expressions have calling priority over "super" expressions.
* undo all inheritance depth checks & code added to the inheritance checking algorithm
Reorder default ctor creation and auto-generation of constructor body.
* Handle same struct types during overload resolution
Changed overload resolution logic to properly handle same struct types; added test to check for multi-param same type function overload.
* remove unused ast object
Used unused object in an incorrect way. This caused the compiler to not flag a warning.
* extension support for default constructors
specialization is not supported with default constructors yet.
* fix bugs
Fix bug in override/overload logic with type comparisons.
used wrong type for ctor list construction
Specialization has not been added yet
* disallow default ctor inside extension
* adjust comment, add new tests
* add explicit types to invoke, use faster default ctor lookup.
* adjust syntax & naming as recomended
|
|
|
|
Fixes the issue #3671
* The __init constructors are not expected to return a value like other member
functions, but must construct a new value and return the struct type or none.
* This patch enables this behavior in the IR lowering without complaining about
illegal situations where the user returns an invalid type or none at all.
Translate ordinary struct `return ...;` to `this = ...; return this;`
Translate NonCopyableType struct `return ...;` to `return this;`
* This patch also fixes the issue with type checking when __init()
returns a void that mismatches the base type of the struct/ class
Translate ordinary struct `return;` to `return this;`
Translate NonCopyableType struct `return;` to `return;`
* Add end-to-end test and compile only tests to check the above behavior.
|
|
(#3881)
* Refactor memory qualifier decorators to be a bit-flag set.
replace GloballyCoherent, ReadOnly, WriteOnly, Volatile, and Restrict memory modifiers and decorations with a bit flag set to more efficiently manage memory qualifiers.
added `restrict` modifier to test to ensure the code works when dropping a `restrict` memory qualifier
* Refine tests & add SSBO memory qualifer support
add CHECK's to tests to ensure memory qualifiers emit as intended
added tests and changed code to ensure memory qualifiers work on SSBO objects (SPIR-V & GLSL)
* add memory qualifiers & fixes.
Add to StructuredBuffer & ByteAddressBuffer `ReadOnly`/NonWritable qualifier.
* Memory qualifiers must be decorated on a variable inst. Due to this the qualifier is added after `lowerStructuredBufferType`
Fixed an error where ReadOnly->NonReadable & WriteOnly->NonWritable
* Adjusted tests accordingly
Added back the removed `globallycoherent` memory qualifier emit'ing code in hlsl-emit (was incorrectly removed).
undo hlsl.meta changes
cleanup
|
|
The following PR implements 8.14-8.19 of the [OpenGL-GLSL specification](https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf).
Fully implements all functions and built-in type's, resolves https://github.com/shader-slang/slang/issues/3692 for GLSL & SPRI-V targets.
_Notes:_
Testing Tools:
* Fragment shaders cannot test computational results. Only OpCodes are checked for proper emitting.
Implementation Notes:
* SubpassInput requires an unknown image format.
* SubpassInput is disjoint from TextureType: __SubpassImpl (.slang) & SubpassInputType (Compiler) to reduce code generation required.
* SubpassInput required an additional input layout modifier, input_attachment_index, this was added as a new parameter binding attribute. Since the following qualifiers can overlap with different resources (`layout(input_attachment_index = 0, binding = 0, set = 0)`) input_attachment_index is checked for overlapping resource bindings separately from other qualifiers with `LayoutResourceKind::InputAttachmentIndex`.
* `GLSLInputAttachmentIndexLayoutModifier` was added to enforce function parameters only accepting `in` decorated variables.
* `in` decorated variables needed to have emitting modified to allow directly emitting the variable into function calls if used as a parameter, normally Slang has a "global variable" shadow as a "global parameter" through a copy. This does not work and is solved using `GlobalVariableShadowingGlobalParameterDecoration` to build a relationship of "global variable" to "global parameter", we then resolve this relationship and replace "global variable" uses later in compile.
* `AtomicCounterMemory` memory-constraint requires `OpCapability AtomicStorage`, `AtomicStorage` is invalid for Vulkan targets. glslang outputs for `barrier`, `memoryBarrier`, and `groupMemoryBarrier` `AtomicCounterMemory` as a memory constraint. This compiles as valid SPIR-V for Vulkan since `OpCapability AtomicStorage` is not declared. This behavior of glslang is undefined as per [3.31.Capability of the SPIR-V specification](https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_capability). We will omit `AtomicCounterMemory` from our barrier calls.
|
|
Resolves an issue #3385
Shader Model 6.6 added a new keyowrd, "WaveSize". See the following link
for more details:
https://microsoft.github.io/DirectX-Specs/d3d/HLSL_SM_6_6_WaveSize.html
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
|
|
* Support mutable existential parameters.
* Update test.
|
|
resolves #3587 for GLSL & SPIR-V targets #3631 (#3810)
* [early push of code since memory qualifiers may be made into a seperate branch & pr and I rather make it simple to split the implementation if required]
all type & functions impl. for GLSL image type
added all memory qualifiers & tests for direct read/write [GLSL syntax] (DID NOT test or implement parameter qualifiers, that is next commit)
* this inlcudes emit-glsl & emit-spirv for qualifier decorations
* this also includes error handling
* this includes parsing
* full implementation other than Rect; all errors and basic tests are done & working
what is left:
1. need to now add Rect type support (additional TextureImpl flag)
2. tests
3. testing infrastructure to support variety of types
* testing framework now works with images of all types and imageBuffers -- next steps are actual tests
* push code for mostly working image atomics; missing int64/uint64 tests and slightly broken feature
likley due to missing code from master which I pushed for regular atomics
* fix all remaining shader image atomic issues and tests to work with float & i64/u64 fully
will now clean up code and squash the commits (since they are quite all over the place)
* refactor code to work & look correct, fix all regressions
Turned off tests for texture format R64 due to the shader use limitation of currently being only for storage buffers on most hardware (test fail cause, this is not allowed)
Changed raygen.slang & nv-ray-tracing-motion-blur.slang since both cross-compiled with glslang, which does not respect layout(rgba8) for RWBuffer's, in this scenario making the type into a SPIR-V rgba32f, which is incorrect and a known problem, this causes different code to be outputted from Slang & HLSL+GLSL->Slang paths
Clean up all code and better explain the "why" for the gimageDim definition we use various strings of Slang code, the gist is:
1. Parameters are structured as per IMAGE_PARAM keyword in spec, and we respect this in order to match specification (to allow easy code iteration)
2. sample parameters are required for functions
3. types are inconsistently named
fixed regression of breaking l-value lowering when r-value should be lowered (lower-to-ir)
fix compiler warnings
remove unneeded lambdas
`expr->type.isLeftValue = isMutableGLSLBufferBlockVarExpr(baseExpr) && (expr->type.hasReadOnlyOnTarget == false);` is an adjustment made such that a buffer block is mutable only if the block is mutable and the base expression is mutable (to handle case of readonly buffer block, immutable)
* remove rectangle parameter
* use proper const syntax and struct naming
* adjust syntax
* adjust modifier capabilitites: HLSL+GLSL --> GLSL. Notice most specifically, if the parent is a global struct we can put a memory qualifier, this does not include, struct inside a struct, with a member variable with a memory qualifier (since then you could use the struct in invalid ways). Added test for struct inside struct with member variable with memory qualifier.
adjust syntax and remove code which will rot
* adjust formatting for consistency
* addressing review feedback
addressing review feedback:
change testing code to handle int and float/half correctly in all cases
adjust testing code syntax as requested
change vkdevice code to fit a different form as requested
* adjust code as per requested for review:
1. adjusted testing code logic to handle non 0-1 values appropriately, notice int8_t will likley be the range and set order of {[0,127],[-1,-128]}, this is intentional
2. syntax adjustments for correctness
* trying to fix falcor regressions
* add back removed code for regression testing
* test removing changes which may break falcor
* Revert "test removing changes which may break falcor"
This reverts commit 240da97f06c23e98a26ac23cf1d385995c67b251.
* disable R64 support in attempt to fix falcor tests
* Revert "disable R64 support in attempt to fix falcor tests"
This reverts commit 317cb632eb2f47e980fc4aeafe418f8060f4c473.
* disable major device changes (still trying to figure out falcor fails -- locally working different than CI)
* test removing d3d changes
* remove all format changes
* add back removed code for regression testing
* try something to get code to work with falcor
* address review
* Add way to handle constref/ref/encapsulated texture objects with memory qualifiers as a parameter.
Fixed an issue (and improved codegen) for when we have a store(dst,load(src)) pattern, where dst is supposed to be equal to src for when resolving globalParam's (no need for work-arounds anymore)
* move recent-fix/change to textureType loading into a proper optimization pass which now runs after SPIR-V legalization to catch odd SPIR-V emitting after legalizing types for SPIR-V
* Revert most recent optimization pass change, add work around getting a unmangled global parameter address through a intrinsic op instead of spir-v intrinsic (works same as `__imagePointer()`)
* remove unneeded changes
* remove unneeded `__constref` in glsl.meta
* move memory qualifier checks to visitInvoke of check-expr.cpp
move GetLegalizedSPIRVGlobalParamAddr resolving to spirv-legalization pass
move error for "if using non texture type with memory qualifer in param" earlier such that we error with this first. No point in telling user "you are not putting correct memory qualifiers" when memory qualifiers should not have been used.
* add memory qualifier folding modifier 'MemoryQualifierCollectionModifier' to reduce searching and processing (later will be adapted to whole system) as suggested/asked.
The utility is a method to track memory qualifiers without doing a expensive linked-list traversal (image's have 4 modifiers normally).
* properly pass multiple qualifiers from checkModifier down to the `modifier`s list
* addressing review comments:
* change implementation to properly handle restrict modifier
* add comments about implementation for clarity
|
|
|
|
|
|
(#3675)
The following PR implements raytracing extensions (GLSL_EXT_ray_tracing, GLSL_EXT_ray_query, GLSL_NV_shader_invocation_reorder & GLSL_NV_ray_tracing_motion_blur); for GLSL & SPIR-V targets. Fully implements all functions, built-in variables, & syntax; resolves #3560 for GLSL & SPIR-V Targets.
notes of worth:
* __rayPayloadFromLocation, __rayAttributeFromLocation, and __rayCallableFromLocation, were added as SPIR-V Intrinsics to refer to location's of raytracing objects in SPIR-V for when using GLSL syntax.
|
|
extension(s); resolves #3587 for GLSL & SPIR-V targets (#3755)
The following commit implements atomic operations & types associated with OpenGL 4.6, GL_EXT_vulkan_glsl_relaxed, GLSL_EXT_shader_atomic_float, GLSL_EXT_shader_atomic_float2, for GLSL & SPIR-V targets.
Fully implements all functions, and built-in type's, resolves https://github.com/shader-slang/slang/issues/3560 for GLSL & SPRI-V targets.
[Atomic extensions for GLSL can be found here](https://github.com/KhronosGroup/GLSL/tree/main)
Notes of worth:
* atomic_uint is well defined in GLSL->OpenGL, although was removed in GLSL->VK unless a compiler extension is supported (GL_EXT_vulkan_glsl_relaxed). This support entails transforming all atomic_uint operations and references into a storage buffer. SPIR-V has AtomicCounter+AtomicStorage (atomic_uint parallel) but does not implement these capabilities for SPIR-V->VK in any scenario. Due to the case we transform atomic_uint ourselves (GLSL_Syntax->Slang_IR) to accommodate transforming atomic_uint into valid syntax.
* GLSL_EXT_shader_atomic_float2 (all float16_t & some float/double operations) support is minimal and worth watching out for if enabling the tests.
|
|
* Enhance link-time type test.
* Fix.
* Fix.
|
|
* Link-time constant and linkage API improvements.
* Fix.
* Allow module name to be empty.
* Fix.
* Fix.
* Fix compile error.
|
|
* Uniformity analysis.
* Add [NonUniformReturn] decorations to some hlsl intrinsic functions.
|
|
|
|
|
|
* Implement short-circuit logic operator
Implement short-circuit evaluation for logic && and ||
operator.
The short-circuit behavior is only used when the operands
involved are scalar and the parent function is non-differentiable.
In implementation, we define a new class 'LogicOperatorShortCircuitExpr'
derived from 'OperatorExpr'. In the visitInvoke() call, we will create
a new expression object 'LogicOperatorShortCircuitExpr' if the
expression is logic && or ||. So that we can generate new IR code in the
new visit function 'visitLogicOperatorShortCircuitExpr' to implement the
short-circuit behavior.
Add new test to test the short-circuit behavior.
* Fix an compile issue occurred in Falcon test
Previously, we early return when at least one of the operands of
"&&" or "||" is vector in convertToLogicOperatorExpr call. However,
in that case the arguments involved in the expression have already been
type checked. When it falls-back to 'visitInvokeExpr', it will check
the arguments again, and some unexpected behavior could occur
which could in turn cause some internal error.
So we add a check in the 'visitInvokeExpr' to avoid double type checking
of arguments.
* Update glsl subgroup test to not use short-circuit
Since the short-circuit evaluation could cause the threads
diverging in subgroup intrinsics. So change the test to not
using "&&" to chain those subgroup intrinsics together. Instead,
using "&" to chain them together because those test functions have
the return value as bool.
* Disable short-circuit in few situations
Disable short-circuit in following situations:
1. generic parameter list
2. static const varible initialization
* Use a flag to indicate the enablement of short-circuit
Instead of using a struct to indicate the state of the outer
environment of current expression, use a simple bool flag to
indicate whether or not apply the short-circuit to current
expression because there few situations where we will disable
short-circuiting and in those circumstances, there is no nested.
Therefore, a flag is good enough to indicate the case.
* Disable short-circuit in index expression
Also fix the build issue. (A cleanup for the last change.)
* check both 'static' and 'const' modifiers
Previously we only check HLSLStaticModifier to decide whether or
not using short-circuit, but we really should check both 'static'
and 'const' modifiers together, because we only want to disable
the short circuit for init expression for 'static const' variable.
* relax the restriction of short-circuit for index expression
Disable the short-circuit for index expression only when declare
an array.
* Simplify the logic by creating subVisitor
Simplify the logic by create a sub expression visitor so
that we don't need to introduce extra recursion.
* Call convertToLogicOperatorExpr after args check
Change to call convertToLogicOperatorExpr after arguments
check in visitInvokeExpr such that we don't have to check
whether the arguments checked to avoid the double checking
issue.
|
|
* Fix lowering logic around imported modules.
* Use actual source loc when emitting SPIRV.
|
|
* Remove duplicate function
* neaten
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Fix crash when generating debug info for geometry shaders.
* Fix.
* Fix source language field in DebugCompilationUnit.
* Fix.
* Emit DebugEntryPoint inst.
* Add trivial test.
* Cleanup.
* More cleanup.
|
|
* Add support for bitfields
Closes https://github.com/shader-slang/slang/issues/3559
* Set scopes for syntsized bitfield accessors
* Simplify generated code for bitfield accessors
* spelling
* regenerate vs project
* warnings
|
|
* [SPIRV] Add NonSemanticDebugInfo for step-through debugging.
* Fix.
* Fix.
|
|
* Allow default values for `extern` symbols.
* Fix.
* Fix test.
|
|
* WAR for ForceInline not working issue in stdlib
Work-around for an issue #3628
This commit allows __init() functions in stdlib to be decleared
without "[__unsafeForceInlineEarly]" or "[ForceInline]".
We need to find a proper solution for the issue later.
* Remove unnecessary checking of the missing body
This fixes an issue #3628
This commmit removes an unnecessary checking of the missing body of the
constructors in stdlib. This change was suggested by Yong.
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
(#3580)
* Partially Implement with tests, functions and built-in variables apart of GL_KHR_shader_subgroup; Partially resolves #3548
Partially Implement with tests, functions and built-in variables apart of GL_KHR_shader_subgroup; Partially resolves #3548
GL_KHR_shader_subgroup implemented based on https://github.com/KhronosGroup/GLSL/blob/main/extensions/khr/GL_KHR_shader_subgroup.txt
Implementation is broken down into seperate glsl extensions due to the ***large differences*** in implementation of each section, and functionality/testing.
GL_KHR_shader_subgroup_basic{
**Partially implemented**
Implementation:
* All 9 built-in variables have been stubbed without proper value; implementation is still required for these system variables; related to #411.
* Functions were reimplemented despite nearly mirrored HLSL functions due to:
* hlsl.meta implementations targetting workgroups rather than a warp/wave/subgroup:
* `__syncwarp` vs `__syncthreads`
* `SubgroupMemory` vs `WorkgroupMemory`
* etc.
* hlsl.meta implementations target broader SPIR-V memory targets to block on:
* ImageMemory|UniformMemory versus SPIR-V specifying barriers for ImageMemory and seperately an option for UniformMemory
* `subgroupElect` for CUDA has a different implementation than `WaveIsFirstLane`, this is because spec states that `subgroupElect()` only returns the lowest active gl_SubgroupInvocationID; therefore we are supposed to fetch the current active mask even if some invocations are turned off by branches
Testing:
tests for the variable -- `tests/glsl/shader-subgroup-built-in-variables.slang`
* these tests do not test functionality since not implemented yet
tests for the functions -- `tests/glsl/shader-subgroup-basic.slang`
* concurrency is tested for using SubgroupMemory, UniformMemory through attempting to create a GPU side race condition with writing and reading memory
* due to testing tools avaible there are no tests for ImageMemory
* subgroupElect is tested to return invocation #0, the lowest invocation that will always run; wave size is 32, therefore #0 is always active and will always be the elected invocation.
}
GL_KHR_shader_subgroup_vote{
**Fully implemented**
Implementation:
* 3/3 functions are using the hlsl.meta implementation
Testing:
`tests/glsl/shader-subgroup-vote.slang`
* Testing each a positive (returns true) and negative (returns false) test case to ensure vote results are correct
}
GL_KHR_shader_subgroup_ballot{
**Partially implemented**
Implementation:
There are 10/10 functions that are implemented:
* 3 are using hlsl.meta implementation
* 7 are using new implementations -- only support GLSL, SPIR-V, HLSL, CUDA
* These implementations do not exist in hlsl.meta, so they were added
* `subgroupInverseBallot` lacks an analog function to call; this feature was emulated:
* in CUDA through knowing waves are 32bit and lanes are 0 indexed, this implys that ` (ballotResult >> YOUR_INVOCATION) & 1` checks if your invocation is active, for example, `(0b11001 >> 3) & 1` would mean that only invocation 5, 4, and 1 is active, 3 would mean `YOUR_INVOCATION` is the fourth invocation in the subgroup. `(0b11001>>3) & 1` would return true since your bit is toggled and evaluates to `0b11 & 0b1`
* in HLSL through testing if the wave count is 32 or less (use the same logic as CUDA in this case); else find the index `YOUR_INVOCATION` corrisponds with where each vector has 32bits (32 waves); avoid division in the process. then run the same algorithm cuda employs.
* `subgroupBallotBitExtract` is logically the same as `subgroupInverseBallot`
* 5 implementations do not have a CUDA, HLSL, and CPP imlementation yet (subgroupBallotFindMSB, subgroupBallotFindLSB, subgroupBallotExclusiveBitCount, subgroupBallotInclusiveBitCount, subgroupBallotBitCount) due to being out of scope for the commit
Testing:
`tests/glsl/shader-subgroup-ballot.slang`
* the function tests for an expected value of each ballot function; tests try inputting larger than 32 toggled bits as function parameters to ensure the implementation correctly identifies values up to a maximum of the subgroup invocation count as per extension specification (otherwise the functionality is fairly trivial to test)
}
GL_KHR_shader_subgroup_arithmetic{
**Partially implemented**
Implementation:
* There are 21 functions to implement:
* 14 functions are using the hlsl.meta implementation
* 7 functions are new implementations -- only implemented for GLSL and SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
* CUDA, CPP, HLSL are out of scope for the commit
Testing:
`tests/glsl/shader-subgroup-arithmetic.slang`
* all tests silently kill the shader; outputted GLSL was checked, could not see an issue
* these tests only check basic functionality and correctness of all functions implemented; not an exaustive test [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_shuffle{
**Partially implemented**
Implementation:
* There are 2 functions to implement:
* 1 function is using the existing hlsl.meta implmentation
* 1 function is using a new implmentation (subgroupShuffleXor) -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle.slang`
* these tests only check basic functionality and correctness of all functions implemented; not an exaustive test [further continued in "Other notes of worthy" at end of commit]
* tests fail with cpp due to `kIROp_WaveGetActiveMask` failing to be called
}
GL_KHR_shader_subgroup_shuffle_relative{
**Partially implemented**
Implementation:
* There are 2 functions to implement:
* all 2 functions are using a new implmentation -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle-relative.slang`
* these tests only check basic functionality and correctness of all functions implemented; not an exaustive test [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_clustered{
**Partially implemented**
Implementation:
* There are 7 functions to implement:
* all 7 functions are using a new implmentation -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle-clustered.slang`
* these tests only check basic functionality and correctness of all functions implemented; not an exaustive test [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_quad{
**Partially implemented**
Implementation:
* There are 4 functions to implement:
* all 4 functions are using hlsl.meta implmentations -- only implemented for GLSL & SPIR-V & HLSL
Testing:
`tests/glsl/shader-subgroup-shuffle-quad.slang`
* these tests only check basic functionality and correctness of all functions implemented; not an exaustive test [further continued in "Other notes of worthy" at end of commit]
}
---------
Failing tests and why:
Note: due to system variables not being implemented largly for CUDA and CPP, these tests will fail (#3 and #4){
tests/glsl/shader-subgroup-arithmetic.slang.3
tests/glsl/shader-subgroup-arithmetic.slang.4
tests/glsl/shader-subgroup-ballot.slang.4
tests/glsl/shader-subgroup-basic.slang.3
tests/glsl/shader-subgroup-basic.slang.4
tests/glsl/shader-subgroup-quad.slang.3
tests/glsl/shader-subgroup-quad.slang.4
tests/glsl/shader-subgroup-vote.slang.3
tests/glsl/shader-subgroup-vote.slang.4
}
Note: due to kIROp_WaveGetActiveMask not being loaded for cpp the following test will fail{
tests/glsl/shader-subgroup-shuffle.slang.4
}
Note: due to a unknown silent error the following will fail [could not spot an error in the generated glsl and spir-v]{
tests/glsl/shader-subgroup-arithmetic.slang.5 (vk)
tests/glsl/shader-subgroup-arithmetic.slang.6 (vk)
}
Other notes of worthy:{
* only a few types are checked currently in tests due to equality templates not allowing freely casting to int/uint, meaning to test types en-mass is not trivial and will most likley be completly replaced once templates can cast & check equality more freely.
* did not implement vector types for any functions that may use them (mostly in reference to SPIR-V, since many may accept scalar or vector inputs); applicable to subgroup-shuffle, subgroup-shuffle-relative, subgroup-arithmetic, subgroup-shuffle, subgroup_clustered, subgroup_quad
* did not implement checks for half floats
* CUDA, CPP, HLSL implementations were largly out of scope and if not implemented, this is due to the implementation not being trivial
}
Random fixes encountered:{
* hlsl.meta incorrectly sets `OpCapability` as `GroupNonUniformBallot` when the `OpCapability` should be `GroupNonUniformVote`; this is as per SPIR-V spec for all SPIR-V calls used in `GL_KHR_shader_subgroup_vote`: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpGroupNonUniformAll
}
* added vector types and tests;
Partially Implement with tests, functions and built-in variables apart of GL_KHR_shader_subgroup; Partially resolves #3548
GL_KHR_shader_subgroup implemented based on https://github.com/KhronosGroup/GLSL/blob/main/extensions/khr/GL_KHR_shader_subgroup.txt
GL_KHR_shader_subgroup_* & GLSL ref:
* https://github.com/KhronosGroup/GLSL/blob/main/extensions/khr/GL_KHR_shader_subgroup.txt
* https://www.khronos.org/blog/vulkan-subgroup-tutorial
* https://www.khronos.org/assets/uploads/developers/library/2018-vulkan-devday/06-subgroups.pdf
HLSL ref:
* https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-intrinsic-functions
* https://github.com/Microsoft/DirectXShaderCompiler/wiki/Wave-Intrinsics
CUDA ref:
* https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html
SPIR-V ref:
* https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_memory_semantics_id
Implementation is broken down into seperate glsl extensions due to the ***large differences*** in implementation of each section, and functionality/testing.
GL_KHR_shader_subgroup_basic{
**Partially implemented**
Implementation:
* All 9 built-in variables have been stubbed without proper value; implementation is still required for these system variables; related to #411.
* Functions were reimplemented despite nearly mirrored HLSL functions due to:
* hlsl.meta implementations targetting workgroups rather than a warp/wave/subgroup:
* `__syncwarp` vs `__syncthreads`
* `SubgroupMemory` vs `WorkgroupMemory`
* etc.
* hlsl.meta implementations target broader SPIR-V memory targets to block on:
* ImageMemory|UniformMemory versus SPIR-V specifying barriers for ImageMemory and seperately an option for UniformMemory
* `subgroupElect` for CUDA has a different implementation than `WaveIsFirstLane`, this is because spec states that `subgroupElect()` only returns the lowest active gl_SubgroupInvocationID; therefore we are supposed to fetch the current active mask even if some invocations are turned off by branches
Testing:
tests for the variable -- `tests/glsl/shader-subgroup-built-in-variables.slang`
* these tests do not test functionality since not implemented yet
tests for the functions -- `tests/glsl/shader-subgroup-basic.slang`
* concurrency is tested for using SubgroupMemory, UniformMemory through attempting to create a GPU side race condition with writing and reading memory
* due to testing tools avaible there are no tests for ImageMemory
* subgroupElect is tested to return invocation #0, the lowest invocation that will always run; wave size is 32, therefore #0 is always active and will always be the elected invocation.
}
GL_KHR_shader_subgroup_vote{
**Fully implemented**
Implementation:
* 3/3 functions are using the hlsl.meta implementation
Testing:
`tests/glsl/shader-subgroup-vote.slang`
* Testing each a positive (returns true) and negative (returns false) test case to ensure vote results are correct
}
GL_KHR_shader_subgroup_ballot{
**Partially implemented**
Implementation:
There are 10/10 functions that are implemented:
* 3 are using hlsl.meta implementation
* 7 are using new implementations -- only support GLSL, SPIR-V, HLSL, CUDA
* These implementations do not exist in hlsl.meta, so they were added
* `subgroupInverseBallot` lacks an analog function to call; this feature was emulated:
* in CUDA through knowing waves are 32bit and lanes are 0 indexed, this implys that ` (ballotResult >> YOUR_INVOCATION) & 1` checks if your invocation is active, for example, `(0b11001 >> 3) & 1` would mean that only invocation 5, 4, and 1 is active, 3 would mean `YOUR_INVOCATION` is the fourth invocation in the subgroup. `(0b11001>>3) & 1` would return true since your bit is toggled and evaluates to `0b11 & 0b1`
* in HLSL through testing if the wave count is 32 or less (use the same logic as CUDA in this case); else find the index `YOUR_INVOCATION` corrisponds with where each vector has 32bits (32 waves); avoid division in the process. then run the same algorithm cuda employs.
* `subgroupBallotBitExtract` is logically the same as `subgroupInverseBallot`
* 5 implementations do not have a CUDA, HLSL, and CPP imlementation yet (subgroupBallotFindMSB, subgroupBallotFindLSB, subgroupBallotExclusiveBitCount, subgroupBallotInclusiveBitCount, subgroupBallotBitCount) due to being out of scope for the commit
Testing:
`tests/glsl/shader-subgroup-ballot.slang`
* the function tests for an expected value of each ballot function; tests try inputting larger than 32 toggled bits as function parameters to ensure the implementation correctly identifies values up to a maximum of the subgroup invocation count as per extension specification (otherwise the functionality is fairly trivial to test)
}
GL_KHR_shader_subgroup_arithmetic{
**Partially implemented**
Implementation:
* There are 21 functions to implement:
* 14 functions are using the hlsl.meta implementation
* 7 functions are new implementations -- only implemented for GLSL and SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
* CUDA, CPP, HLSL are out of scope for the commit
Testing:
`tests/glsl/shader-subgroup-arithmetic.slang`
* all tests silently kill the shader; outputted GLSL was checked, could not see an issue
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_shuffle{
**Partially implemented**
Implementation:
* There are 2 functions to implement:
* 1 function is using the existing hlsl.meta implmentation
* 1 function is using a new implmentation (subgroupShuffleXor) -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
* tests fail with cpp due to `kIROp_WaveGetActiveMask` failing to be called
}
GL_KHR_shader_subgroup_shuffle_relative{
**Partially implemented**
Implementation:
* There are 2 functions to implement:
* all 2 functions are using a new implmentation -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle-relative.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_clustered{
**Partially implemented**
Implementation:
* There are 7 functions to implement:
* all 7 functions are using a new implmentation -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle-clustered.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_quad{
**Partially implemented**
Implementation:
* There are 4 functions to implement:
* all 4 functions are using hlsl.meta implmentations -- only implemented for GLSL & SPIR-V & HLSL
Testing:
`tests/glsl/shader-subgroup-shuffle-quad.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
---------
Failing tests and why:
Note: test numbers are assuming none of the existing tests are toggled off
Note: due to system variables not being implemented largly for CUDA and CPP, these tests will fail (#3 and #4){
tests/glsl/shader-subgroup-arithmetic.slang.3
tests/glsl/shader-subgroup-arithmetic.slang.4
tests/glsl/shader-subgroup-ballot.slang.4
tests/glsl/shader-subgroup-basic.slang.3
tests/glsl/shader-subgroup-basic.slang.4
tests/glsl/shader-subgroup-quad.slang.3
tests/glsl/shader-subgroup-quad.slang.4
tests/glsl/shader-subgroup-vote.slang.3
tests/glsl/shader-subgroup-vote.slang.4
}
Note: due to kIROp_WaveGetActiveMask not being loaded for cpp the following test will fail{
tests/glsl/shader-subgroup-shuffle.slang.4
tests/glsl/shader-subgroup-shuffle-relative.slang.4
tests/glsl/shader-subgroup-basic.slang.4
}
Note: due to a unknown silent error the following will fail [could not spot an error in the generated glsl and spir-v]{
tests/glsl/shader-subgroup-arithmetic.slang.5 (vk)
tests/glsl/shader-subgroup-arithmetic.slang.6 (vk)
}
Other notes of worthy:{
* only a few types are checked currently in arithmetic test; this is due to the test silently failing, meaning I can't actually test anything implemented
* did not implement checks for half floats
* CUDA, CPP, HLSL implementations were largly out of scope and not implemented, this is due to the implementation being non trivial for many functions
}
Random fixes encountered:{
* hlsl.meta incorrectly sets `OpCapability` as `GroupNonUniformBallot` when the `OpCapability` should be `GroupNonUniformVote`; this is as per SPIR-V spec for all SPIR-V calls used in `GL_KHR_shader_subgroup_vote`: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpGroupNonUniformAll
}
* Partially Implement with tests, functions and built-in variables apart of GL_KHR_shader_subgroup; Partially resolves #3548
Partially Implement with tests, functions and built-in variables apart of GL_KHR_shader_subgroup; Partially resolves #3548
GL_KHR_shader_subgroup implemented based on https://github.com/KhronosGroup/GLSL/blob/main/extensions/khr/GL_KHR_shader_subgroup.txt
GL_KHR_shader_subgroup_* & GLSL ref:
* https://github.com/KhronosGroup/GLSL/blob/main/extensions/khr/GL_KHR_shader_subgroup.txt
* https://www.khronos.org/blog/vulkan-subgroup-tutorial
* https://www.khronos.org/assets/uploads/developers/library/2018-vulkan-devday/06-subgroups.pdf
HLSL ref:
* https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-intrinsic-functions
* https://github.com/Microsoft/DirectXShaderCompiler/wiki/Wave-Intrinsics
CUDA ref:
* https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html
SPIR-V ref:
* https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_memory_semantics_id
Implementation is broken down into seperate glsl extensions due to the ***large differences*** in implementation of each section, and functionality/testing.
GL_KHR_shader_subgroup_basic{
**Partially implemented**
Implementation:
* All 9 built-in variables have been stubbed without proper value; implementation is still required for these system variables; related to #411.
* Functions were reimplemented despite nearly mirrored HLSL functions due to:
* hlsl.meta implementations targetting workgroups rather than a warp/wave/subgroup:
* `__syncwarp` vs `__syncthreads`
* `SubgroupMemory` vs `WorkgroupMemory`
* etc.
* hlsl.meta implementations target broader SPIR-V memory targets to block on:
* ImageMemory|UniformMemory versus SPIR-V specifying barriers for ImageMemory and seperately an option for UniformMemory
* `subgroupElect` for CUDA has a different implementation than `WaveIsFirstLane`, this is because spec states that `subgroupElect()` only returns the lowest active gl_SubgroupInvocationID; therefore we are supposed to fetch the current active mask even if some invocations are turned off by branches
Testing:
tests for the variable -- `tests/glsl/shader-subgroup-built-in-variables.slang`
* these tests do not test functionality since not implemented yet
tests for the functions -- `tests/glsl/shader-subgroup-basic.slang`
* concurrency is tested for using SubgroupMemory, UniformMemory through attempting to create a GPU side race condition with writing and reading memory
* due to testing tools avaible there are no tests for ImageMemory
* subgroupElect is tested to return invocation #0, the lowest invocation that will always run; wave size is 32, therefore #0 is always active and will always be the elected invocation.
}
GL_KHR_shader_subgroup_vote{
**Fully implemented**
Implementation:
* 3/3 functions are using the hlsl.meta implementation
Testing:
`tests/glsl/shader-subgroup-vote.slang`
* Testing each a positive (returns true) and negative (returns false) test case to ensure vote results are correct
}
GL_KHR_shader_subgroup_ballot{
**Partially implemented**
Implementation:
There are 10/10 functions that are implemented:
* 3 are using hlsl.meta implementation
* 7 are using new implementations -- only support GLSL, SPIR-V, HLSL, CUDA
* These implementations do not exist in hlsl.meta, so they were added
* `subgroupInverseBallot` lacks an analog function to call; this feature was emulated:
* in CUDA through knowing waves are 32bit and lanes are 0 indexed, this implys that ` (ballotResult >> YOUR_INVOCATION) & 1` checks if your invocation is active, for example, `(0b11001 >> 3) & 1` would mean that only invocation 5, 4, and 1 is active, 3 would mean `YOUR_INVOCATION` is the fourth invocation in the subgroup. `(0b11001>>3) & 1` would return true since your bit is toggled and evaluates to `0b11 & 0b1`
* in HLSL through testing if the wave count is 32 or less (use the same logic as CUDA in this case); else find the index `YOUR_INVOCATION` corrisponds with where each vector has 32bits (32 waves); avoid division in the process. then run the same algorithm cuda employs.
* `subgroupBallotBitExtract` is logically the same as `subgroupInverseBallot`
* 5 implementations do not have a CUDA, HLSL, and CPP imlementation yet (subgroupBallotFindMSB, subgroupBallotFindLSB, subgroupBallotExclusiveBitCount, subgroupBallotInclusiveBitCount, subgroupBallotBitCount) due to being out of scope for the commit
Testing:
`tests/glsl/shader-subgroup-ballot.slang`
* the function tests for an expected value of each ballot function; tests try inputting larger than 32 toggled bits as function parameters to ensure the implementation correctly identifies values up to a maximum of the subgroup invocation count as per extension specification (otherwise the functionality is fairly trivial to test)
}
GL_KHR_shader_subgroup_arithmetic{
**Partially implemented**
Implementation:
* There are 21 functions to implement:
* 14 functions are using the hlsl.meta implementation
* 7 functions are new implementations -- only implemented for GLSL and SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
* CUDA, CPP, HLSL are out of scope for the commit
Testing:
`tests/glsl/shader-subgroup-arithmetic.slang`
* all tests silently kill the shader; outputted GLSL was checked, could not see an issue
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_shuffle{
**Partially implemented**
Implementation:
* There are 2 functions to implement:
* 1 function is using the existing hlsl.meta implmentation
* 1 function is using a new implmentation (subgroupShuffleXor) -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
* tests fail with cpp due to `kIROp_WaveGetActiveMask` failing to be called
}
GL_KHR_shader_subgroup_shuffle_relative{
**Partially implemented**
Implementation:
* There are 2 functions to implement:
* all 2 functions are using a new implmentation -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle-relative.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_clustered{
**Partially implemented**
Implementation:
* There are 7 functions to implement:
* all 7 functions are using a new implmentation -- only implmented for GLSL & SPIR-V
* GLSL & SPIR-V both use their related functions, no emulation required
Testing:
`tests/glsl/shader-subgroup-shuffle-clustered.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
GL_KHR_shader_subgroup_quad{
**Partially implemented**
Implementation:
* There are 4 functions to implement:
* all 4 functions are using hlsl.meta implmentations -- only implemented for GLSL & SPIR-V & HLSL
Testing:
`tests/glsl/shader-subgroup-shuffle-quad.slang`
* these tests only check basic functionality and correctness of all functions implemented; [further continued in "Other notes of worthy" at end of commit]
}
---------
Failing tests and why:
Note: test numbers are assuming none of the existing tests are toggled off
Note: due to system variables not being implemented largly for CUDA and CPP, these tests will fail (#3 and #4){
tests/glsl/shader-subgroup-arithmetic.slang.3
tests/glsl/shader-subgroup-arithmetic.slang.4
tests/glsl/shader-subgroup-ballot.slang.4
tests/glsl/shader-subgroup-basic.slang.3
tests/glsl/shader-subgroup-basic.slang.4
tests/glsl/shader-subgroup-quad.slang.3
tests/glsl/shader-subgroup-quad.slang.4
tests/glsl/shader-subgroup-vote.slang.3
tests/glsl/shader-subgroup-vote.slang.4
}
Note: due to kIROp_WaveGetActiveMask not being loaded for cpp the following test will fail{
tests/glsl/shader-subgroup-shuffle.slang.4
tests/glsl/shader-subgroup-shuffle-relative.slang.4
tests/glsl/shader-subgroup-basic.slang.4
}
Other notes of worthy:{
* added preamble function and macros for implementing subgroup functionality (and tests) to make it possible to iterate on the functionality with reasonable effort in the future
* CUDA, CPP, HLSL implementations were largly out of scope and not implemented, this is due to the implementation being non trivial for many functions
* doubles cause a silent crash on most subgroup functions tested (silent shader hang)
* __requireGLSLExtension does not work as intended inside glsl.meta; as a result half, int16, int64 int8, all are ommited from testing
}
Random fixes encountered:{
* hlsl.meta incorrectly sets `OpCapability` as `GroupNonUniformBallot` when the `OpCapability` should be `GroupNonUniformVote`; this is as per SPIR-V spec for all SPIR-V calls used in `GL_KHR_shader_subgroup_vote`: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpGroupNonUniformAll
* hlsl.meta incorrectly uses for WaveMaskPrefixBitOr (SPIR-V) OpGroupNonUniformBitwiseAnd intead of OpGroupNonUniformBitwiseOr; this was fixed
}
* redesign tests under suggestions that they should be smaller, more maintainable, and test the most amount of data reasonabley possible (balance with fast iterations);
optional double testing
varying parameter testing
most tests chain results now
* fix missing impl and merge conflict resolutions
* reundant test code cleanup and organization
move tests to proper location (glsl-intrinsic)
clean up redundant code (input buffers)
* add missing logical operands support (and remove hlsl/cuda code reuse due to the functional differences) under all And, Or, Xor ops
redesign tests to conform to a better testing paradigm
* testing code style change to not use white space as a toggle for tests
* provided crash reason for doubles (intel iris gpu's crash in glsl with doubles due to missing support in device caps [as per vulkan validation layer)
uncommented the `__requireGLSLExtension` code so once it is fixed int16/8/64/half wil work with subgroup not requiring future intervention
* fixing some vk validation layer errors (OpMemoryBarrier, Shuffle operations)
modified style of tests; removed redundancy (extra code that does nothing); fixed some incorrect run targets; added error reasons for all encountered problems (and if needed, a #define/#if toggle)
* remove comments of important tests inplace of #define over the broken feature of extended shader_subgroup types
* removed macros inside glsl.meta
removed erroneous __target_switch to directly call hlsl.meta function
added elaboration on the problem with __requireGLSLExtension
changed WaveMaskPrefixBit[or|and|xor] to support the expected type of <int> only as per `HLSL Shader Model 6.5` specs
removed "precision highp" since it does not affect tests
* changes some hlsl.meta functions used to be more appropriate (as per suggested)
WaveMask -> WaveActive.*
WaveMaskPrefix.* -> WavePrefix.*
remove __target_switch case's for unimplemented case's of intrinsics
fix _getLaneId() being removed from some regex used earlier
* fix usage of __target_intrinsic instead of __intrinsic_asm; silently would cause only arguments to be emmitted as return
changed usage of `__requireGLSLExtension` because now it causes a crash from the missing intrinsic (instead of a silent error)
* fix shader subgroup extended types support for GLSL and SPIR-V:
1. seperate intrinsic/__requireGLSL generating functionality of shader_subgroup_preamble into child function calls due to otherwise `__requireGLSLExtension` being ignored if the calling function of shader_subgroup_preamble calls an `__intrinsic_asm`
2. fixed HLSL.meta logic for wave operations (Add, Mul, exclusiveAdd, exclusiveMul) to no longer cast the input type T into a uint due to cost-of-op & crash.
* Int8_t bit casted into uint32_t crashed the compiler. As per SPIR-V spec, OpGroupNonUniformI.* work on uint and int types meaning the function has no need to cast to a unit.
3. removed erroneous __target_switch for subgroupShuffle
* 1. ignore tests gracefully
2. remove un-needed SPIRV capability specifying (with OpCapability)
3. clean up structure of typeRequireChecks_shader_subgroup_GLSL
4. explain why HLSL/CUDA are not targeted for shader-subgroup-arithmetic.slang
* syntax changes + `property` declaration fix + builtin var glsl implementation + changed incorrect HLSL.meta assumptions
(#1)`property` declaration as *non member* implementation change/fix (all of the changes to `slang-lower-to-ir.cpp`)
using (#1), implemented subgroup builtin's for GLSL/SPIR-V; did not implement built'ins completly for HLSL/CUDA due to non trivial implementations. CPP has no implementation due to missing support of system values
changed some incorrect HLSL.meta subgroup implementation assumptions of type usage (bit casting 8bit->32bit, wrong capabilities causing errors)
dumping ast crash with spir-v when using builtin's fixed by adding the `builtin` spirv case (all of the changes to `slang-ast-dump.cpp`)
[ForceInline] addition to functions missing it
return instead of spirv_asm when empty blocks are used
* syntax & organization of tests adjustment (specifically how if'def's are managed)
* figuring out where ci fails
* figuring out where ci fails -- testing with enclusive & regular
* testing CI with exclusive, regular, inclusive
* remove unneeded white space
test CI inconsistency issues further with arithmetic.slang
* testing if the ci run fails due to some timeout/recovery issue
* split up arithmetic tests and push to test with CI
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
