| Age | Commit message (Collapse) | Author |
|---|
|
* Revert "Disable OptiX tests by default. (#1331)"
This reverts commit e45f8c1f49855cebe90b6722324ec24146ff5a3d.
* Enable optix submodule to build
Add support for default entry points in compilation
Implemented logic to check for defined entry points in the module
when no explicit entry points are provided. If found, these entry points
are added to the `specializedEntryPoints` list, with the assumption that
no specialization is needed for them at this time.
* Disable optix if cuda is not enabled
* Add submodule OptixSDK path in search
* Distinguish user-explicit vs auto-detected SLANG_ENABLE_OPTIX
When SLANG_ENABLE_OPTIX is explicitly set by user and CUDA is not available,
show SEND_ERROR to maintain strict validation. When OptiX is auto-detected
(e.g., local submodule present) but CUDA unavailable, gracefully disable
with STATUS message to allow builds to continue.
This addresses review feedback to keep error for explicit requests while
handling auto-detection gracefully.
* Apply CMake formatting to SLANG_ENABLE_OPTIX validation logic
* revert: slang-rhi changes
as those are merged independently as in PR # slang-rhi#400
|
|
* Fix the ignored unit-tests on retry
* Retrigger CI
* Add more error messages
* Don't use test-server for retry of unit-test to see error messages
* Clean up cl.yml
Remove 'has-gpu' because it is unused after debug became full-gpu-test.
Renamed files to make the meaning more clear:
- Renamed expected-failure.txt to expected-failure-via-glsl.txt
- Renamed expected-failure-github-runner.txt to expected-failure-no-gpu.txt
* Rename cpu-hello-world.slang to avoid name conflict to example
We have an example whose executable name is cpu-hello-world.exe.
It gets built when you run `cmake --build`, but it gets overwritten by
slang-test when it tests `tests/cpu-program/cpu-hello-world.slang`.
This PR renames to avoid the name conflict.
* Remove debug code
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
The "textDocument/publishDiagnostics" Notification in the official
Language Server Protocol, or LSP for short, is a notification that
the server sends to the client such as VSCode or Visual Studio
without the client having to ask for it. Its purpose is to provide
a list of errors, warnings, or other informational "squiggles" for
a specific file.
Because the notification is an asynchronous push notification, it
is receieved as an unexpected RPC message during the slang-test CI
tests. When a notificatoin is unexpectedly sent to slang-test, the
communication goes out-of-sync and the rest of language-server
based tests intermittently fails.
In order to address the problem, this PR adds a new command-line
argument to change the behavior of the notification and it will
be sent in a more deterministic manner where the notification can
be sent only in one of three cases: didOpen, didChange, and
didClose. Because these evets are only ways to cause a new
notification, we can still expect to get the same diagnostic
messages without missing any of them. For slang-test CI test,
this new option will be used to make the notification more
deterministic.
|
|
On Linux/MacOS, the test file lists were not in a sorted order and the order was non-deterministic.
It causes intermittent CI failures.
This commit is to make the list sorted and CI more reliable.
|
|
* update slang-rhi
* adapt to new slang-rhi API
* enable slang-rhi agility sdk
* fix handling empty list
* disable failing slang-rhi tests
* format code
* fix slang-rhi-tests ci step
* skip running slang-rhi-tests
---------
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
|
|
* Break down RecordReply to individual tests to avoid timeout
In Debug build, RecordReplay unit-test was timing out.
It was running six tests all in one unit-test, but this commit breaks it
down to individual test so that each unit test can be done within the
timeout limit.
This issue has seen only in Debug build but it has been unnoticed
because even when the test failed with test-server, it was still passing
on its retry because the time-out applies only when using test-server.
* Reduce the retry from 2 times to 1 time
* Remove RecordReplay from expected failure
|
|
* Add a new slang-test option `-enable-debug-layers`
A variable `disableDebugLayer` is renamed to `enableDebugLayers`,
and a corresponding command-line argument is added,
`-enable-debug-layers`.
The previous option `-disable-debug-layer` is still available, but it
prints a deprecation warning message.
The reason why it is added is to make the option available to both Debug
and Release. On Debug build, it will be enabled by default, and it will
be disabled on Release build. We should be able to not only disable it,
but also enable it on Release build.
Ideally this option should be enabled all the time, but currently there
are too many VUID error messages printed and we are enabling only for
Debug build for now.
Note that the CI/CD will run with the option disabled until we resolve
all of VUID errors.
|
|
Previously when running slang-test with "-use-test-server" to run
slang-unit-test-tool and gfx-unit-test-tool tests, these would
fail with a message like, "error: Unable to launch tool". These issues
appear to have been resolved, however debug runs of gfx-unit-test-tool
using "-use-test-server" were still showing errors of the following
nature:
````
error: rpc failed
error: result code = -858993460
standard error = {
}
standard output = {
}
ignored test: 'gfx-unit-test-tool/uint16BufferTestVulkan.internal'
````
These errors all appeared to be the result of Vulkan VUID print outs
and were occuring for nearly every Vulkan test.
Existing comments in slang-test-main.cpp indicated that VUID print outs
get misinterpreted as the result from a test due to limitations in the
Slang RPC implementation. Slang-test then correctly disables use of VK
debug layers when the spawn type is UseTestServer. However, this argument
is only passed to the test server when running standard tests (see
ExecuteToolTestArgs vs ExecuteUnitTestArgs).
This change hard codes `unitTestContext.enableDebugLayers = false;` in
test-server-main.cpp when running unit tests, as otherwise this will
currently result in all Vulkan tests being ignored.
Additional tweaks were made to slang-test-main.cpp to restore the spawn
type for unit tests and to prevent bogus rpc error result codes.
|
|
* skip recordReplay; fix retrying logic for unit test
* Allow the CI to run with manual dispatch
* increase failed test limit to 100
* reduce the serve count to 2
|
|
* Unify Debug Layer Control Logic and Add Disable Option for Debug Builds
This PR refactors and unifies the debug layer control logic in slang-test.
A new `-disable-debug-layers` option is introduced, allowing debug builds to skip enabling the validation (debug) layer.
This is currently needed to ensure stability in the debug test suite.
Previously, different toggles such as ENABLE_VALIDATION_LAYER, ENABLE_DEBUG_LAYER, and debugLayerEnabled were used inconsistently across different components of slang-test. This PR standardizes the logic by using a single variable, debugLayerEnabled, to control the enabling/disabling of the debug layer internally.
Notes:
By default, the debug/validation layer is enabled in debug builds and is not supported in release builds of slang-test.
Fixes: #7132
* Disable spirv-opt for the DebugFunctionDefinition issue
* Run debug build only in GCP machines
* Fix VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818
dstAcessMask can't include VK_ACCESS_TRANSFER_READ_BIT when stage mask
has VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR
* Set failed retry limit to 32
---------
Co-authored-by: slangbot <ellieh+slangbot@nvidia.com>
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
|
|
|
|
This PR allows the failed unit-tests to be retried at the end as in a single threaded manner.
The purpose of the retry is to increase the stability of CI.
|
|
* Correct incorrect enum usage on metal
* Update C++ standard to C++20
Closes https://github.com/shader-slang/slang/issues/6945
* use bit_cast
|
|
* Add Slang Byte Code generation and interpreter.
* Fix compile issues.
* format code
* More compile fix.
* Fix clang issue.
* Fix more clang issues.
* Another clang fix.
* Fix clang issues.
* Fix another clang issue.
* Fix wasm build.
* Update building.md
* Fix test-server.
* Fix compile error.
* Fix bug.
---------
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
|
|
* A new approach to AST serialization
This change completely overhauls the way that AST nodes are being serialized, and the offline source-code generation steps that enable that serialization.
In practice, this ends up being a complete overhaul of the way that *modules* are being serialized (not just the AST part), although things like the serialization format for the Slang IR and for source locations are not affected.
The rest of this commit message is broken down in to sections, in an attempt to help guide anybody looking at the code in how to make sense of all the changes.
The Old C++ Extractor
---------------------
AST serialization used to be driven by information scraped using the `slang-cpp-extractor` tool, which did an ad hoc parse of the C++ declarations of the AST node types and then generated a set of "X macros" that could be for macro-based code generation within the rest of the compiler.
While the existing approach was functional, it wasn't easy to understand or maintain, and it has been getting in the way of forward progress on other features we'd like to work on in the language and compiler.
This change removes the `slang-cpp-extractor` tool entirely.
Marking Up the AST Declarations
-------------------------------
The most notable change that contributors to the compiler may notice is the large number of invocations of a macro `FIDDLE()` on the declarations of the AST node types.
The basic idea is that only declarations (namespaces, types, fields) that are preceded by `FIDDLE()` are visible to the code generator tool.
So if somebody is working with the AST and wondering why a new node type isn't working, or why a field they added isn't being serialized correctly, it is probably because they need to add `FIDDLE()` in front of it.
Generating the Boilerplate Code
-------------------------------
The file `slang-ast-boilerplate.cpp` provides a good example of how the information extracted from the marked-up AST declarations gets used.
In that file, the `FIDDLE TEMPLATE` construct is used to generate type information for each of the AST node types.
Similar logic is used in `slang-ast-forward-declarations.h` to generate the declaration of the `ASTNodeType` enumeration, and forward-declare all the AST node classes.
For many parts of the code, simply including that file replaces the need for the old `slang-generated-*.h` files.
Replacing Visitors and Related Logic
------------------------------------
The old visitor types for the AST used the macros that were generated by `slang-cpp-extractor`, so something new was needed to replace them.
The same goes for the `SLANG_AST_NODE_VIRTUAL_CALL` macros.
The core of the solution implemented here is in `slang-ast-dispatch.h`.
Given a "dispatchable" AST node type (say, `Expr`), a call like:
```
ASTNodeDispatcher<Expr,R>(expr, [&](auto e) { return doSomething(e); })
```
is an expression of type `R`, which does the equivalent of something like:
```
switch(expr->getTag())
{
case ASTNodeType::VarExpr: return doSomething(static_cast<VarExpr*>(expr));
// ...
}
```
The `SLANG_AST_NODE_VIRTUAL_CALL` macro is now implemented in terms of `ASTNodeDispatcher`.
The implementation of the visitor types is more involved.
The code in this change retains some of the macro names from the original version, just to try and make the parallels more clear.
The visitor types are all implemented on top of the `ASTNodeDispatcher` approach, and use `FIDDLE TEMPLATE` to generate all the boilerplate `visit*()` method declarations.
Refactoring of `Linkage` Module Loading
---------------------------------------
Needing to revisit all the places where modules get deserialized made it clear that there is a lot of complexity and apparent duplication in the core routines on the `Linkage` that get used for loading modules.
This change tries to clean up some of that logic, but it is worth noting that there are two legacy features that get in the way of making things as clean as they should be:
* The `LoadedModuleDictionary` type that gets passed around a lot exists entirely to handle the corner case where somebody uses the Slang API to perform a compilation with multiple `TranslationUnitRequest`s in the same `FrontEndCompileRequest`, and one of the translation units `import`s the module defined by another of the translation units.
* There are a lot of special-case behaviors and routines entirely there to support the `ModuleLibrary` feature, although that feature should be considered deprecated (or at least subject to getting entirely re-designed down the line).
The basic idea of the cleanup is that all of the (non-deprecated) ways load a module from a serialized binary, or compile one from source should now bottleneck through `loadModuleImpl`, which then bifurcates into `loadSourceModuleImpl` for the compilation case and `loadBinaryModuleImpl` for the deserialization case.
High-Level Serialization Approach
---------------------------------
The old serialization logic used the [RIFF](https://en.wikipedia.org/wiki/Resource_Interchange_File_Format) format to encode the high-level structure of things, and this change retains that usage (and actually doubles down on the RIFF usage).
The old serialization system relied on the idea that for any given type `Foo` that wants to support serialization, there should be something like a `SerialFooData` type in C++, that can represent the state of a `Foo`, and then the actual serialization applied to that `SerialFooData`. This means that in most cases there are four pieces of code written:
* During serialization:
* Copying the data of a `Foo` in memory over to a `SerialFooData` in memory
* Writing the state of a `SerialFooData` into the serialized data stream
* During deserialization:
* Reading the state of a `SerialFooData` from a serialized data stream
* Copying the data of the `SerialFooData` in memory over to a `Foo`
The new logic gets rid of the intermediate `SerialFooData`.
In the serialization direction, we take a `Foo` and write it to the `RIFFContainer` directly, or using some other utilities layered on top of it.
In the deserialization direction, we have additional flexibility. Given a `RIFFContainer::Chunk*` that represents a serialized `Foo`, we often navigate through the in-memory representation of the RIFF data to get to the parts of the serialized value that we actually want/need, without needing to deserialize the entire `Foo`.
To support this kind of operation, this change introduces a few helper types like `ContainerChunkRef` an `ModuleChunkRef`, that are little more than typed wrappers around a `RIFFContainer::Chunk*`.
The Module "Container" Part
---------------------------
A serialized `Module` is encoded as a RIFF chunk, using logic in `slang-serialize-container.cpp` - both before and after this change.
This change reorganizes a lot of the code in that file, to account for the way that eliminating the intermediate `SerialContainerData` type streamlines the overall task of writing out the parts of the module.
In the deserialization logic... there isn't really much to do in `slang-serialize-container.cpp`. Most of the logic in `slang.cpp` and `slang-module-library.cpp` that pertains to deserializing modules uses the `ModuleChunkRef`-based approach, and simply extracts the pieces of the serialized module that it needs.
The Actual Serialization of the AST
-----------------------------------
The actual AST serialization logic is in `slang-serialize-ast.cpp`.
The basic approach in both the writing and reading directions is:
* Use the `FIDDLE TEMPLATE` system to generate a set of functions, one for each AST node type, that recursively invoke the read/write logic on each field of that node (after recursively invoking the case for its direct superclass)
* Use the `ASTNodeDispatcher` system to dispatch out to those functions whene reading or writing anything derived from `NodeBase`
* For now, handle all types *not* derived from `NodeBase` by hand.
There's a lot of room for improvement around that last item: it should be just as easy to generate the serialization and deserialization logic for other types that don't inherit from `NodeBase`, but the current change tries to err on the side of making the logic as explicit and simplistic as possible, rather than trying to get too clever too soon.
The actual serialization *format* used for the AST is almost comically simplistic: the code uses hierarchical RIFF chunks to emulate a JSON-like structure. This is a very wasteful representation (e.g., a `bool` or a null pointer each take up *8 bytes*), but the goal for now is to start with the simplest thing that could possibly work, and only add more cleverness once we are sure it won't get in the way of important future improvements (like lazy/on-demand deserialization or IR and AST, to improve compiler startup times).
The files `slang-serialize.{h,cpp}` have been co-opted to define a new pair of types `Encoder` and `Decoder` that are used for a more-or-less stream-oriented way or reading or writing RIFF chunks for the JSON-like structure.
Almost everything related to the actual AST serialization could do with a cleanup pass, and some time spent on picking good/better names for everything.
Smaller Stuff
-------------
* Cleaned up a lot of code that was using bare `ASTNodeType` or the extractor's `ReflectClassInfo` type to consistently use `SyntaxClass`.
* Fixed an apparent bug in how the destination-driven code genarator was handling `TryExpr`s
* Fixed an apparent bug in how the GLSL legalization pass was handling translation of certain `SV_*` semantics.
* format code
* fixup: template errors caught by non-VS compilers
* format code
* fixup: more template errors
* fixup: more stuff VS didn't catch
* fixup: it's amazing VS doesn't catch these...
* fixup: yet more template stuff VS ignores
* fixup: more VS template nonsense
* fixup: unreachable return macro usage
* fixup: more unreacable returns
* fixup: unused parameter
* fixup: strict aliasing
* fixup: allow missing entry point list chunk
* fixup: wasm build script
* fixup: AST changes since this PR was created
---------
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* fix(d3d11): correct parameter in VSSetConstantBuffers1 from uavCount to cbvCount (fixes #6531)
Root cause - Incorrect parameter passing in slang-rhi
1. slang-rhi #281 - Add the correct cbvCount for setting Constant Buffer
2. Prevent render tests from overwriting reference images
* Add missing tests/render/multiple-stage-io-locations.slang.3.expected.png
* Add more expected images from texture2d-gather
* Add new option: skipReferenceImageGeneration
For Github CI we set this to true - So we don't overwrite the expected
images
---------
Co-authored-by: Jay Kwak <82421531+jkwak-work@users.noreply.github.com>
|
|
This commit adds a help screen to slang-test to improve usability;
and update README.md with clearer instructions.
The help screen is displayed when:
- User explicitly requests help with -h or --help flags
- An unknown option is provided
- A required argument for an option is missing
The help screen provides comprehensive documentation of all available options,
organized into sections:
- Basic options (e.g. bindir, test-dir)
- Output modes (e.g. appveyor, travis, teamcity)
- Test prefix usage explanation
Fixes: #6560
Co-authored-by: Ellie Hermaszewska <ellieh@nvidia.com>
|
|
This closes issue #4771.
|
|
Fixes #6390
This commit removes the deprecated -adapter command-line option from
slang-test.
This change aligns with commit 015bde8d5a46f32979c00dbb1feb4b3d80729c44,
which previously removed the adapter option from render-test and implemented
the more AdapterLUID mechanism.
Co-authored-by: Ellie Hermaszewska <ellieh@nvidia.com>
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* remove unused resource
* define buffer data
* add vs2022 build presets
* update slang-rhi API usage
* update slang-rhi
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Allow `.member` syntax on vector and scalars.
* Fix.
* fix.
* Fix.
* update comment.
* Fix tests.
* Fix warning.
* Add more tests.
|
|
When -show-adapter-info is provided to slang-test, there is a subsequent pass over all available APIs to ask render-api to show which adapter will be used.
> .\slang-test.exe -show-adapter-info
Supported backends: fxc dxc glslang spirv-dis clang visualstudio genericcpp nvrtc llvm spirv-opt tint
Check vk,vulkan: Supported
Check dx12,d3d12: Supported
Check dx11,d3d11: Supported
Check cuda: Supported
Check wgpu,webgpu: Supported
Adapter Information for Available APIs:
vk,vulkan:
Using graphics adapter: NVIDIA RTX A3000 Laptop GPU
dx12,d3d12:
Using graphics adapter: NVIDIA RTX A3000 Laptop GPU
dx11,d3d11:
Using graphics adapter: Intel(R) UHD Graphics
cpu:
cuda:
wgpu,webgpu:
Using graphics adapter: default
passed test: 'tests/autodiff/arithmetic-jvp.slang (dx11)'
...
closes #5600
* format code
---------
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
|
|
This helps to address #4760.
|
|
* Cache and reuse glsl module.
* Fix.
* Implement record/replay for the new api.
* Fix record replay.
* Fix test.
|
|
* Avoid using the backend validation when using test server
Currently with a debug build, the backend validation such
as Vulkan-Validation-Layer or DXC validation is enabled all the time.
It means there is a higher chance that we see warning messages while
running slang-test with a debug build.
However, those warning messages incorrectly treated as the testing
result when using test-server. This is mainly because of the fact that
the Slang implemention for the RPC commucation expects only one time
output result. As soon as any warning is printed, the testing process is
incorrectly considered as completed even though it might be still in the
middle of initializing the device.
This commit disables the backend validation when using the test-server.
* format code (#31)
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
---------
Co-authored-by: slangbot <ellieh+slangbot@nvidia.com>
Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Properly set D3D12SDKPath
Closes https://github.com/shader-slang/slang/issues/5992
This commit have an effect on slang-test.exe and test-server.exe.
When we run slang-test.exe, it uses D3D12Core.DLL located at
`build/{Release,Debug}/bin/D3D12`, which is `D3D12` from where the
executable file is located at.
This has been working fine but we found a case where it doesn't work
properly. This commit sets D3D12SDKPath value explicitly to avoid
potential problems.
|
|
|
|
Co-authored-by: Ellie Hermaszewska <ellieh@nvidia.com>
|
|
This stops adding the repo root to the include path for anything linking
with slang. This enabled a bunch of convenient includes, but might lead
to confusing behavior for anyone including slang. Not to mention
differences including it from an install vs source.
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
Update slang-rhi to pick up a fix in webgpu compilation error handling.
In doRenderComparisonTestRun(), only return TestResult::Pass if the
shader is ran actually compiled.
A similar check is in place elsewhere in slang-test-main, but was
missed in doRenderComparisonTestRun().
Add two tests to the github CI skiplist, and use the skiplist in one
additional CI config that was running without it.
Closes 5291
|
|
* Move switch statement bodies to their own lines
* format
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* format
* Minor test fixes
* enable checking cpp format in ci
|
|
This commit renames the files and projects to prefer "core-module" over
"stdlib".
The directory name `source/slang-stdlib` needs to be renamed too, and
there will be another commit for it soon.
|
|
This is a breaking change in a way that the Slang API function names are changed. All of them are commented as "experimental" and we wouldn't provide a back-ward compatibility for them.
Following functions are renamed:
compileStdLib() -> compileCoreModule()
loadStdLib() -> loadCoreModule()
saveStdLib() -> saveCoreModule()
slang_createGlobalSessionWithoutStdLib() -> slang_createGlobalSessionWithoutCoreModule()
slang_getEmbeddedStdLib() -> slang_getEmbeddedCoreModule()
hasDeferredStdLib() -> hasDeferredCoreModule()
Following command-line arguments are renamed:
"-load-stdlib" -> "-load-core-module"
"-save-stdlib" -> "-save-core-module"
"-save-stdlib-bin-source" -> "-save-core-module-bin-source"
"-compile-stdlib" -> "-compile-core-module"
|
|
D3D12Core.dll had been copied to a wrong directory and slang has been using D3D12Core.dll from the system directory, C:\windows\system32.
D3D12Core.dll has to be copied from external/slang-binaries/bin/windows-x64 to build/Release/bin/D3D12 not to build/Release/bin.
The same is true for the debug build and it had to be copied to build/Debug/bin/D3D12 not build/Debug/bin.
It hasn't been a problem for Release build, because the debug-layer is not enabled for Release build and it didn't cause the version mismatching problem with D3D12SDKLayers.dll. The Release build was loaded from either build/Release/bin or from C:\windows\system32, and it didn't matter which one was used.
The Debug build, however, got into a problem where D3D12Core.dll was loaded from the system directory whereas D3D12SDKLayers.dll was loaded from build/Debug/bin and it failed to load D3D12.dll entirely. This caused D3D12 to be "Not supported" for "Windows/Debug" configuration. Note that our CI explicitly excludes DX12 tests for the "Windows/Debug" configuration with a command-line argument "-api all-dx12", and DX12 tests were going to be ignored anyway.
The actual problem was observed when WGPU is implemented. WGPU started printing explicit errors for the load failure of D3D12.dll.
See more detailed explanation:
https://devblogs.microsoft.com/directx/gettingstarted-dx12agility/#d3d12sdkpath-should-not-be-the-same-directory-as-the-application-exe
Closes #5305
Closes #5276
|
|
* Squash redundant move warnings
* Move C interface from slang.h to slang-deprecated.h
spGetBuildTagString remains, because it's useful to have before the
global session exists.
This C API is used quite pervasively in the C++ helpers (for example
slang::UserAttribute. It's not trivial to move these to
slang-deprecated.h as they're entangled with some enums which are
themselves used elsewhere in the compiler.
The fact that these helpers use the C API can be viewed as an
implementation detail for now, and this usage moved to slang-deprecated
in due course.
Closes https://github.com/shader-slang/slang/issues/4758
* Squash warnings for our usage of our deprecated API
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Fix assert when compiling an entrypoint that calls another entrypoint.
* Fix test.
|
|
|
|
* Use the assembly description as target when disassembling
I believe this is a bugfix.
It seems to have worked before because up until the WGSL case, the disassembler has been
the same executable as the one producing the binary to be disassembled.
* Add Tint as a downstream compiler
This closes issue #5104.
* Add downstream compiler for Tint.
* Tint is wrapped in a shared library, 'slang-tint' available from [1].
* The header file for slang-tint.dll is added in external/slang-tint-headers.
* Add some boilerplate for WGSL targets.
* Add an entry point test for WGSL.
[1] https://github.com/shader-slang/dawn/releases/tag/slang-tint-0
* Add WGSL_SPIRV as supported target for Glslang
* Add WebGPU support to slang-test
This helps to address issue #5051.
* Disable lots of crashing compute tests for 'wgpu'
This closes issue #5051.
---------
Co-authored-by: Yong He <yonghe@outlook.com>
|
|
* Add options to prevent usage of own submodules
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Allow using external unordered dense headers
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Link system wide installed unordered dense
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Allow external header usage for lz4 and spirv
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Add more options to disable targets
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Add option to provide explizit path for spirv headers and remove earlier options that break the build process
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Rename options to use common prefix
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Fix indentation for the cmake changes
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Add advanced_option function for cmake
* Normalize includes between system and submodule dependencies
Fix any before-accidentally-working problems
* Add option for enabling/disabling slang-rhi
Signed-off-by: Jacki <jacki@thejackimonster.de>
* Pass correct include path for cpu tests
* Correct include path
---------
Signed-off-by: Jacki <jacki@thejackimonster.de>
Co-authored-by: Ellie Hermaszewska <ellieh@nvidia.com>
|
|
My previous commit disabled the WGSL test by a mistake. This commit fixes the mistake and run the slang-test for WGSL tests.
frexp and modf were still not working for the vector types.
|
|
* Implement math intrinsics for WGSL
This commit implements math related intrinsics and a few others for
WGSL.
The implementation is based on the following doc,
https://www.w3.org/TR/WGSL
slang-test was looking for the downstream compiler for WGSL even though
it is not used.
This commit adds a minimal change to avoid the crash.
|
|
* 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 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.
|
|
* Fix IR lowering for generic interface types.
* Fix.
* Fix.
|
|
Co-authored-by: Jay Kwak <82421531+jkwak-work@users.noreply.github.com>
|
|
* 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
|
|
|
|
When slang-test.exe ran with a file name doesn't exactly match
character-by-character, those tests don't run.
This commit alters the file name given from the command-line and it will
behave in a more expected way.
- "./" are removed.
- "../" gets removed along with its parent directory name.
- Back-slash characters will be converted to slash on Windows.
|
|
* Add host shared library target.
* Attempt fix.
* Fix warnings.
* try fix.
* Fix test.
* Fix.
|
