| Age | Commit message (Collapse) | Author |
|---|
|
We've implemented a function in slang-record-replay unit test
to remove the non-empty directory, now move this function into
slang `Path` namespace to make this function as an utility.
Close issue #4916
|
|
Adding a user guide page for SPIR-V specific features.
|
|
* Change `slang.h` path in `slang-common.h` to allow `slang-embed` to resolve correctly.
* Change `slang.h` path in all slang/core files
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
|
|
* Refactor the IComponentType recording
Refactor the `IComponentType` recording by creating a abstract class
`IComponentTypeRecorder` to record all the methods of `IComponentType`,
so that `ICompositeComponentType`, `IModule`, 'IEntryPoint',
'ITypeConformance' can share the same recording implementation.
Capture the out IComponentType from
linkWithOptions()
link()
specialize()
renameEntryPoint()
* fix bugs
* Finish the unimeplemented functions in json consumer
Fix the address print to use 64 bit hex.
Fix the reference count issue when allocating new recorder object.
* Disable few examples using reflection APIs
* Add gpu-printing example into slang-test
* Replace of using std::unique_ptr with RefPtr
|
|
* Support specialization constants.
* Fix.
* Fix.
* Fix.
* Fix.
* Make sure specialization constants have names.
* Clean up and support the dxc [vk::constant_id] syntax.
* Fix.
* Fix.
* Fix.
|
|
* add slang-rhi submodule
* refactor render-test to use slang-rhi and remove OpenGL support
* remove -vk -glsl tests
* remove gl test
* disable failing test
* allow recursive submodules in github actions
* update slang-rhi
* update slang-rhi
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Fix redundant decorations in IRParam
Closes #4922
The problem was that same decorations were added to an IRParam multiple
times while running `specializeIRForEntryPoint()`.
`cloneGlobalValueWithCodeCommon()` kept cloning decorations for the
params that were already processed.
|
|
* Support mixture of precompiled and non-precompiled modules
This changes the implementation of precompile DXIL modules to
accept combinations of modules with precompiled DXIL, ones without,
and ones with a mixture of precompiled DXIL and Slang IR.
During precompilation, module IR is analyzed to find public functions
which appear to be capable of being compiled as HLSL, and those
functions are given a HLSLExport decoration, ensuring they are emitted
as HLSL and preserved in the precompiled DXIL blob. The IR for those
functions is then tagged with a new decoration AvailableInDXIL, which
marks that their implementation is present in the embedded DXIL blob.
The DXIL blob is attached to the IR as before, inside a EmbeddedDXIL
BlobLit instruction.
The logic that determines whether or not functions should be
precompiled to DXIL is a placeholder at this point, returning true
always. A subsequent change will add selection criteria.
During module linking, the full module IR is available, as well
as the optional EmbeddedDXIL blob. The IR for functions implemented
by the blob are tagged with AvailableInDXIL in the module IR.
After linking the IR for all modules to program level IR, the IR for
the functions marked AvailableInDXIL are deleted from the linked IR,
prior to emitting HLSL and compiling linking the result.
This change also changes the point of time when the module IR is
checked for EmbeddedDXIL blobs. Instead of happening at load time
as before, it happens during immediately before final linking, meaning
that the blob does not need to be independently stored with the module
separate from the IR as was done previously.
Work on #4792
* Clean up debug prints
* Call isSimpleHLSLDataType stub
* Address feedback on precompiled dxil support
Allow for IR filtering both before and after linking.
Only mark AvailableInDXIL those functions which pass
both filtering stages. Functions are corrlated using
mangled function names.
Rather than delete functions entirely when linking with
libraries that include precompiled DXIL, instead convert
the IR function definitions to declarations by gutting
them, removing child blocks.
* Use artifact metadata and name list instead of linkedir hack
* Use String instead of UnownedStringSlice
* Update tests
* Renaming
* Minor edits
* Don't fully remove functions post-link
* Unexport before collecting metadata
|
|
* Fix typo SV_DomainLsocation
* Fix CI failures
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Make sure `NullDifferential` and its witness are removed after autodiff.
* Fix.
* Add a test.
|
|
|
|
|
|
* Convert 'ray-tracing-pipeline' example into slang-test
* Convert model-view and 'autodiff-texture' examples to slang-test
* Add more error message in RecordReplay test
* Fix a shader issue in autodiff-texture
|
|
* Ignoring construct field warnings on delegatory methods
* Generalizing instruction usage type interface
* Skip collection when searching for stores
* Adding separate construct delegation tests
* Treating differentiable functions as stores
|
|
|
|
* Metal: mesh shading skeleton
* Metal: fixing mesh payload
* Metal: improving mesh shader indices output
* Metal: Implementing conditional mesh output set
* Metal: Trying to not break other backends
* Metal: trying to fix mesh output set
* Metal: Fixing MeshOutputSet usages
* Metal: Fixing vertex and primitive semantics
* Metal: Fixing code style
* Metal: Fixed hlsl indices set
* Fixed HLSL mesh output set disappearing and GLSL mesh output crashing
* Metal: Adjusting task test matching
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Allow capabilities to be used with `[shader("...")]`
Fixes: #4917
Changes:
1. Allow using capabilities instead of `Stage`s with `EntryPointAttribute`.
2. When resolving capabilities for an entrypoint+profile (per entrypoint) in `resolveStageOfProfileWithEntryPoint` add our `EntryPointAttribute` and resolved capability
3. Added tests and some capabilities related clean-up
* fix a warning made by a mistake in syntax
* change fineStageByName to assume it is passed a stage without a '_'
* test with and without prefix '_'
* cleanup some profiles and reprisentation to work better with 'Stage' and 'Profile'
This use case is why we need to clean all profile-usage into `CapabilityName`s directly.
* change how we compare
* only change profiles
* let all capabilities be resolved by 'shader' profile for now
* fix warning checks I accidently broke
* meshshading_internal to _meshshading
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
|
|
|
|
1. Document `__ref` in stdlib.
2. Remove `__ref` example in `docs\user-guide\a1-04-interop.md`
3. New example in `docs\user-guide\a1-04-interop.md` to compensate for no longer providing an example that uses `&` and `OpCapability`/`OpExtension`.
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
side effects (#4707)
* Adds a warning for using prefer-recompute on methods that contain side effects
* Rename `SideEffects` -> `SideEffectBehavior`
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
|
|
(#4909)
* More reflection API features.
+ Lookup methods and members (by string) on types
+ Fix issue with looking up non-static members through the scope operator '::'
+ `GenericReflection`: Cast a decl to generic to access unspecialized generic parameter names and constraints
+ `GenericReflection`: Use `getGenericContainer()` from function, variable or type to access the 'nearest' generic parent along with specialization info
+ `GenericReflection::getConcreteType` and `GenericReflection::getConcreteIntVal`: to get the concrete type of a param in the context of the reflection object
+ `GenericReflection::getOuterGenericContainer` to go up one level and get the outer generic declarations (if there are more than one enclosing generic scopes)
+ `DeclReflection::getParent`: go to parent declaration.
+ Change `VariableReflection` to be a `DeclRef` rather than a decl (allows us to return properly substituted types for methods, members, and more)
* Fix Falcor issue
* Initial namespace reflection support
* FIx issue with specializing witness tables
* Add API method for specializing parameters of a generic decl
* Add ability to specialize generic references to functions, types and more
This PR adds the following end-points:
- `specializeGeneric()` method that can be called on a generic reflection to substitute arguments for generic type and value parameters. It returns another generic reflection, but this time with the appropriate substitution.
- `applySpecializations()` method to then copy these specializations onto an existing type or function reflection.
- `isSubType()` to check if a type is a subtype of another type (useful to check if a type is differentiable by checking `IDifferentiable`)
This PR also:
- Adds `DeclReflection::Kind::Namespace` so that namespace containers are correctly reflected when walking the decl-tree. the name can be obtained through `getName()` but there's no need to cast to a namespace (since there's nothing else we can do with a namespace decl)
- Fixes an issue with name-based lookups that fail if a type or function is referenced without specializations. Its helpful to be able to form a reference to a function with default substitutions, so that we can we can specialize it later (either directly, or via argument types).
* Update slang.h
* Fix up naming
* Update slang-compiler.h
* Update slang-reflection-api.cpp
* Update slang.cpp
* Update slang.cpp
* Update slang.cpp
* Use `checkGenericAppWithCheckedArgs` to do specialization
* Update slang-reflection-api.cpp
* Update slang-check-decl.cpp
|
|
differentiable args (#4901)
* Explicitly detach derivative when forming a non-differentiable struct out of differentiable args
This fixes an issue where initializer lists get optimized out and lose information about non-differentiability.
There are 2 places where this could have been fixed:
1. When coercing initializer-list exprs, we can check for non-differentiable aggregate types and use a detach derivative on all the args.
2. Add an extra case in the peephole optimization step that adds detach-derivative when simplifying a make-struct of a non-differentiable type.
Even though solution 2 is more elegant, this PR goes with solution 1 simply to avoid having to use a differentiable-type-conformance-context that is used in the auto-diff IR passes to check for differentiability.
* Change test name + add expected vals
|
|
* Migrate cpu-hello-world to new slang API
Migrate cpu-hello-world to new slang API, and also convert this example
as one of the unit test.
* Add 'shader-object' to slang-unit-test
* Convert ray-tracing example into unit-test
Convert ray-tracing example into unit-test
* Fix some replay bugs:
- Wrong decode type in 'getEntryPointHostCallable'.
- Mistakes in computing the output buffer size.
- Wrong decode type in array size in specialize() call.
- When capture entrypoint, we should increase the reference count
for the allocated entrypoint recorder object, because that is
allocated by record layer, it should be owned by the layer, user
should not be able to free it.
- Improve json consumer on the prelude text.
* Test verify change:
In our test, we add a "callIdx" string at beginning of the hash-code
string, as there could be more than one modules in the example, so they
could call 'getEntryPointHash' multiple times, in order for the test
can identify them, add "callIdx: <number>" as the key word.
|
|
* Fix Varying Variable Location Assignments With Hull Shaders
Fixes: #4913
Fixes: #4540
Changes:
1. Added `kIROp_ControlBarrier` to HLSL/GLSL emitting.
2. Added a method to track 'used' and 'unused' varyings for when legalizing GLSL. This allows us to assign correct offsets to automatically added varyings
* Added a `ZeroLSB` check to UIntSet for this purpose
* add missing return
* code comment adjustment
* cleanup
* comment and HLSL controlBarrier mistake
* assume space for glsl/spriv varying is irrelevant
|
|
* Implement `-fvk-use-dx-layout`
Fixes: #4126
Changes:
* Added fvk-use-dx-layout
* Modified `HLSLConstantBufferLayoutRulesImpl` for correctness (ex: Array is always 16 byte aligned)
* Added kFXCShaderResourceLayoutRulesFamilyImpl and kFXCConstantBufferLayoutRulesFamilyImpl to handle fvk-use-dx-layout
* Added `ConstantBufferLayoutRules` to manage constant buffer rules
* Added `alignCompositeElementOfNonAggregate`/`alignCompositeElementOfAggregate` to handle forced alignment of composites for ConstantBuffers
* `StructuredBuffer` rules are mostly equal to `scalar` layout, not much was needed to be changed to support this behavior.
* seperate legacy constant buffer and how Slang does constant-buffer normally
* undo an addition
* remove accidental test
* Address review and fix
Address review and remove GLSL support since GLSL requires a seperate legalization (need to linearlize structs like with `legalizeMetalIR` to assign explicit offsets)
* comments
* remove aggregate and non-aggregate logic
We don't need this distinction for the logic
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Fix the slang-test bug
Since we reorganize the build directory, now the libraries are
located at different directory with executables in non-Windows
platform, we have to change the code on how to find the dll directory.
* Integrate the record/replay test into slang-unit-test
We create a unit-test-record-replay.cpp to run the converted slang
examples in child process as our tests for the record-replay layer.
* Disable the test on Apple
Due to the limitation of current examples, we temporarily disable them
on apples.
Change the ci to make this test only be run on the gpu-equipped runners,
for other runners we add a white-list file
"expected-failure-record-replay-tests.txt".
* Remove 'hello-world' example from unit test
"hello-world" doesn't use gfx abstract library, instead it uses vk directly, it's
not a preferable way. So we will drop this test, instead, we will use cpu-hello-world
example.
|
|
|
|
* record/replay: Add tests
Modify the hello-world example to generate the hash code for the
entry point spirv code, so that we can compare it with replaying
the example.
Add the test script to run the example and compare the hash code
with replaying it.
* Check nullptr for out Diagnostics
We need to check whether the output Diagnostics is a nullptr,
because it's allowed.
* Fix the double free pointers
* Add triangle example as the new test for record-replay
Change the example base to add the offline rendering path
because we don't want to display anything when we're in the
test mode.
This change involves introducing a TestBase that will parse
the command line option. It will decide whether we are in
the test mode.
Disable all the swapchain and windows related creation, instead
we will only create one single framebuffer for the render target.
* Address comments
TODO:
In the follow up patches, I will add more tests and integrate the test flow into slang-unit-test.
|
|
* Support dependent generic constraints.
* Fix warning.
* Update comment.
* Fix.
* Add a test case to verify fix of #3804.
* Address review.
|
|
* Exclude synthesized code from code auto documentation system
Fixes #4888
Changes to exclude synthesized code from code-auto-documentation system
* syntax change for cleanup
|
|
hang (#4885)
* Track uninitialized values of `Ptr<Specialize<T>>` inside type `T` without hang
Fixes #4878
Track uninitialized values of `Ptr<Specialize<T>>` inside type `T` without hang
* change method used to resolve base of specialization
|
|
track containor-decl with `DifferentialType` scope varaible synthesized
|
|
* Implement Path::createDirectoryRecursive
Implement Path::createDirectoryRecursive with existing Path::createDirectory
that uses system call instead of c++ standard lib.
* Change the use of 'while(1)' to 'for(;;)'
|
|
* Remove using SpvStorageClass values casted into AddressSpace values
Also removes support for specific storage classes in __target_intrinsic snippets
* remove SLANG_RETURN_NEVER macro
* squash warnings
* Make nonexhaustive switch statement error on gcc
* Add SLANG_EXHAUSTIVE_SWITCH_BEGIN/END macros
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Tuple swizzling and element access.
* Update proposal status.
* Cleanup.
* Fix merrge error.
* Address review.
|
|
* Variadic Generics Part 2: IR lowering and specialization.
* Update design doc status.
* Update design doc.
* Resolve review comments.
|
|
|
|
|
|
Previously, the warnings were:
```
environment.slang(22): warning 41022: inout parameter 'seed' is never written to
public float3 environment_sample(StructuredBuffer <Environment_sample_data> sample_buffer, inout int seed)
^~~~~~~~~~~~~~~~~~
hit.slang(5): warning 41022: inout parameter 'seed' is never written to
float3 sample_lights(inout uint seed)
^~~~~~~~~~~~~
```
With this commit they should not be emitted.
|
|
|
|
* Make precompileForTargets work with Slang API
precompileForTargets, renamed to precompileForTarget, does not need
an EndToEndCompileRequest and some objects created from it are not
necessary either.
Take only a target enum and a diagnostic blob as input and handle
everything else internally, such as creating the TargetReq with
chosen profile.
Fixes #4790
* Update slang-module.cpp
* Update slang-module.cpp
|
|
|
|
* Do not zero-initialize groupshared and rayquery variables
Fixes: #4824
`-zero-initialize` option will explicitly not:
1. Set any groupshared values to defaults
2. Set any rayQuery object to a default state (currently invalid code generation)
* grammer
* disallow groupshared initializers
disallow groupshared initializers & adjust tests accordingly
* remove disallowed groupshared-init expression
* do not default init if non-copyable
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Fix the issue that NonUniformResourceIndex is ignored
Fix the issue that after `specializeFunctionCalls`,
`NonUniformResourceIndex` is ignored in the generated specialized
function.
The reason is that if the function has a non-uniform resource parameter,
we will legalize it by replacing the resource parameter with a index,
and indexing of the resource will be moved inside the specialized function.
e.g.
```
void func(ResourceType resource) { ... }
func(resource[NonUniformResourceIndex(0)])
```
will be specialized into
```
void func(int index) { resource[index]; }
func(0);
```
In this case, inside the function, we will loose the information about
whether the resource is a non-uniform. So we add the handling for this
corner case by adding insert a `NonUniformResourceIndex` into the
specialized function:
```
void func(int index) {
int nonUniformIdx = NonUniformResourceIndex(index);
resource[nonUniformIdx];
}
```
* Fix the issue that arguments mismatch after specilization callsite
specializeCall() call could cause arguments mismatch with the parameters
of the specialized function.
For example, if the function parameter contains a resource type
```
void func(ResourceType res) { ... }
int index = ...
func(resources[index]);
```
This will be specialized into
```
void func(int index) { resources[index] }
int index = ...
func(index);
```
However, if we have more than 1 call sites, and the other call site
doesn't use `int` as the index, e.g.
```
uint index = ...
func(resources[index]);
```
this call site will be specialized into
```
uint index = ...
func(index);
```
this will be invalid, because the argument doesn't match the parameter.
so we just add the data type of the new arguments into the function key such that
For the uniformity info, we add a new attribute "IROp_NonUniformAttr",
so we will form a IRAttributedType that encodes both uniformity and data
type, and use it as the key of call info. So if there is call site using the different
data type for the resource index, we will specialize a new function for this.
* Handle the intCast and uintCast operation
Since after intCast/uintCast of nonuniformIndex, it's still a
nonuniformIndex. So we will handle this case as well.
Also, add a new test to cover this.
|
|
Adds a new Github CI action for benchmarking the slangc compiler on the MDL shaders. For now, the results are only dumped to the output of the CI, which can be later viewed through raw logs. The next step is to use github-action-benchmark to push these results into a page which will show the benchmark results over time as commits are pushed.
|
|
|
|
Fixes #4818
Emit memory qualifier once for GLSL targets.
Co-authored-by: Yong He <yonghe@outlook.com>
|
