Skip to content

builtin: update inline spirv hlsl #739

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 6 commits into
base: master
Choose a base branch
from
Open

builtin: update inline spirv hlsl #739

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
d94c9cc
builtin: update inline spirv hlsl
alichraghi Sep 3, 2024
6d51fca
builtin: remove wrong comment
alichraghi Sep 9, 2024
76c1617
builtin: temp cmake
alichraghi Sep 9, 2024
65064e8
builtin: update glsl_compat layer to represent new spirv_intrisics
alichraghi Sep 10, 2024
16fc27d
builtin: saner CMakeLists.txt (still not working)
alichraghi Sep 10, 2024
f816d46
builtin: fix cmake
alichraghi Sep 11, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 11 additions & 9 deletions include/nbl/builtin/hlsl/glsl_compat/core.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -135,21 +135,21 @@ SquareMatrix inverse(NBL_CONST_REF_ARG(SquareMatrix) mat)
*/
// TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `&` :(
//void gl_Position() {spirv::}
uint32_t gl_VertexIndex() {return spirv::VertexIndex;}
uint32_t gl_InstanceIndex() {return spirv::InstanceIndex;}
uint32_t gl_VertexIndex() {return spirv::builtin::VertexIndex;}
uint32_t gl_InstanceIndex() {return spirv::builtin::InstanceIndex;}

/**
* For Compute Shaders
*/

// TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `const&` :(
uint32_t3 gl_NumWorkGroups() {return spirv::NumWorkGroups;}
uint32_t3 gl_NumWorkGroups() {return spirv::builtin::NumWorkgroups;}
// TODO: DXC BUG prevents us from defining this!
uint32_t3 gl_WorkGroupSize();
uint32_t3 gl_WorkGroupID() {return spirv::WorkgroupId;}
uint32_t3 gl_LocalInvocationID() {return spirv::LocalInvocationId;}
uint32_t3 gl_GlobalInvocationID() {return spirv::GlobalInvocationId;}
uint32_t gl_LocalInvocationIndex() {return spirv::LocalInvocationIndex;}
uint32_t3 gl_WorkGroupID() {return spirv::builtin::WorkgroupId;}
uint32_t3 gl_LocalInvocationID() {return spirv::builtin::LocalInvocationId;}
uint32_t3 gl_GlobalInvocationID() {return spirv::builtin::GlobalInvocationId;}
uint32_t gl_LocalInvocationIndex() {return spirv::builtin::LocalInvocationIndex;}

void barrier() {
spirv::controlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
Expand Down Expand Up @@ -182,21 +182,23 @@ struct bitfieldExtract<T, isSigned, false>
}
};

// TODO: redundant T
template<typename T>
struct bitfieldExtract<T, true, true>
{
static T __call( T val, uint32_t offsetBits, uint32_t numBits )
{
return spirv::bitFieldSExtract<T>( val, offsetBits, numBits );
return spirv::bitFieldExtract( val, offsetBits, numBits );
}
};

// TODO: redundant T
template<typename T>
struct bitfieldExtract<T, false, true>
{
static T __call( T val, uint32_t offsetBits, uint32_t numBits )
{
return spirv::bitFieldUExtract<T>( val, offsetBits, numBits );
return spirv::bitFieldExtract( val, offsetBits, numBits );
}
};
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Inline SPIR-V should have exact same names as Op enums, except without Op and the leading letter should be lowercase

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

alos why do you think T is redundant?

P.S. now I realize the overload choice chould have been done nicer with enable_if_t


Expand Down
44 changes: 22 additions & 22 deletions include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@
#ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_ARITHMETIC_INCLUDED_
#define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_ARITHMETIC_INCLUDED_

#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl"
#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"

namespace nbl
{
Expand All @@ -17,93 +17,93 @@ namespace glsl
// TODO: Furthermore you'll need `bitfieldExtract`-like struct dispatcher to choose between int/float add/mul and sint/uint/float min/max
template<typename T>
T subgroupAdd(T value) {
return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveAdd(T value) {
return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveAdd(T value) {
return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

template<typename T>
T subgroupMul(T value) {
return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformIMul_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveMul(T value) {
return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformIMul_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveMul(T value) {
return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformIMul_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

template<typename T>
T subgroupAnd(T value) {
return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveAnd(T value) {
return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveAnd(T value) {
return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

template<typename T>
T subgroupOr(T value) {
return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveOr(T value) {
return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveOr(T value) {
return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

template<typename T>
T subgroupXor(T value) {
return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveXor(T value) {
return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveXor(T value) {
return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

template<typename T>
T subgroupMin(T value) {
return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveMin(T value) {
return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveMin(T value) {
return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

template<typename T>
T subgroupMax(T value) {
return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}
template<typename T>
T subgroupInclusiveMax(T value) {
return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}
template<typename T>
T subgroupExclusiveMax(T value) {
return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

}
Expand Down
32 changes: 16 additions & 16 deletions include/nbl/builtin/hlsl/glsl_compat/subgroup_ballot.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@
#ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BALLOT_INCLUDED_
#define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BALLOT_INCLUDED_

#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_ballot.hlsl"
#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
#include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"

namespace nbl
Expand All @@ -15,62 +15,62 @@ namespace glsl
{

// TODO: Extemely annoying that HLSL doesn't have referencies, so we can't transparently alias the variables as `const&` :(
uint32_t4 gl_SubgroupEqMask() {return spirv::BuiltInSubgroupEqMask;}
uint32_t4 gl_SubgroupGeMask() {return spirv::BuiltInSubgroupGeMask;}
uint32_t4 gl_SubgroupGtMask() {return spirv::BuiltInSubgroupGtMask;}
uint32_t4 gl_SubgroupLeMask() {return spirv::BuiltInSubgroupLeMask;}
uint32_t4 gl_SubgroupLtMask() {return spirv::BuiltInSubgroupLtMask;}
uint32_t4 gl_SubgroupEqMask() {return spirv::builtin::SubgroupEqMask;}
uint32_t4 gl_SubgroupGeMask() {return spirv::builtin::SubgroupGeMask;}
uint32_t4 gl_SubgroupGtMask() {return spirv::builtin::SubgroupGtMask;}
uint32_t4 gl_SubgroupLeMask() {return spirv::builtin::SubgroupLeMask;}
uint32_t4 gl_SubgroupLtMask() {return spirv::builtin::SubgroupLtMask;}

template<typename T>
T subgroupBroadcastFirst(T value)
{
return spirv::subgroupBroadcastFirst<T>(spv::ScopeSubgroup, value);
return spirv::groupNonUniformBroadcastFirst<T>(spv::ScopeSubgroup, value);
}

template<typename T>
T subgroupBroadcast(T value, const uint32_t invocationId)
{
return spirv::subgroupBroadcast<T>(spv::ScopeSubgroup, value, invocationId);
return spirv::groupNonUniformBroadcast<T>(spv::ScopeSubgroup, value, invocationId);
}

uint32_t4 subgroupBallot(bool value)
{
return spirv::subgroupBallot(spv::ScopeSubgroup, value);
return spirv::groupNonUniformBallot(spv::ScopeSubgroup, value);
}

bool subgroupInverseBallot(uint32_t4 value)
{
return spirv::subgroupInverseBallot(spv::ScopeSubgroup, value);
return spirv::groupNonUniformInverseBallot(spv::ScopeSubgroup, value);
}

bool subgroupBallotBitExtract(uint32_t4 value, uint32_t index)
{
return spirv::subgroupBallotBitExtract(spv::ScopeSubgroup, value, index);
return spirv::groupNonUniformBallotBitExtract(spv::ScopeSubgroup, value, index);
}

uint32_t subgroupBallotBitCount(uint32_t4 value)
{
return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
}

uint32_t subgroupBallotInclusiveBitCount(uint32_t4 value)
{
return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
}

uint32_t subgroupBallotExclusiveBitCount(uint32_t4 value)
{
return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
}

uint32_t subgroupBallotFindLSB(uint32_t4 value)
{
return spirv::subgroupBallotFindLSB(spv::ScopeSubgroup, value);
return spirv::groupNonUniformBallotFindLSB(spv::ScopeSubgroup, value);
}

uint32_t subgroupBallotFindMSB(uint32_t4 value)
{
return spirv::subgroupBallotFindMSB(spv::ScopeSubgroup, value);
return spirv::groupNonUniformBallotFindMSB(spv::ScopeSubgroup, value);
}
}
}
Expand Down
14 changes: 7 additions & 7 deletions include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@
#define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BASIC_INCLUDED_

#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl"
#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"

namespace nbl
{
Expand All @@ -16,16 +16,16 @@ namespace glsl
#ifdef __HLSL_VERSION
// TODO: Extemely annoying that HLSL doesn't have referencies, so we can't transparently alias the variables as `const&` :(
// NOTE: These are not `uint16_t` even though they could be, because IIUtSC they're `uint32_t` in SPIR-V
uint32_t gl_SubgroupSize() {return spirv::SubgroupSize;}
uint32_t gl_SubgroupSizeLog2() {return firstbithigh(spirv::SubgroupSize);}
uint32_t gl_SubgroupInvocationID() {return spirv::SubgroupLocalInvocationId;}
uint32_t gl_SubgroupSize() {return spirv::builtin::SubgroupSize;}
uint32_t gl_SubgroupSizeLog2() {return firstbithigh(spirv::builtin::SubgroupSize);}
uint32_t gl_SubgroupInvocationID() {return spirv::builtin::SubgroupLocalInvocationId;}

// only available in compute
uint32_t gl_NumSubgroups() {return spirv::NumSubgroups;}
uint32_t gl_SubgroupID() {return spirv::SubgroupId;}
uint32_t gl_NumSubgroups() {return spirv::builtin::NumSubgroups;}
uint32_t gl_SubgroupID() {return spirv::builtin::SubgroupId;}

bool subgroupElect() {
return spirv::subgroupElect(spv::ScopeSubgroup);
return spirv::groupNonUniformElect(spv::ScopeSubgroup);
}

void subgroupBarrier() {
Expand Down
10 changes: 5 additions & 5 deletions include/nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@
#ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_SHUFFLE_INCLUDED_
#define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_SHUFFLE_INCLUDED_

#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl"
#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"

namespace nbl
{
Expand All @@ -15,25 +15,25 @@ namespace glsl
template<typename T>
T subgroupShuffle(T value, uint32_t invocationId)
{
return spirv::groupShuffle<T>(spv::ScopeSubgroup, value, invocationId);
return spirv::groupNonUniformShuffle<T>(spv::ScopeSubgroup, value, invocationId);
}

template<typename T>
T subgroupShuffleXor(T value, uint32_t mask)
{
return spirv::groupShuffleXor<T>(spv::ScopeSubgroup, value, mask);
return spirv::groupNonUniformShuffleXor<T>(spv::ScopeSubgroup, value, mask);
}

template<typename T>
T subgroupShuffleUp(T value, uint32_t delta)
{
return spirv::groupShuffleUp<T>(spv::ScopeSubgroup, value, delta);
return spirv::groupNonUniformShuffleUp<T>(spv::ScopeSubgroup, value, delta);
}

template<typename T>
T subgroupShuffleDown(T value, uint32_t delta)
{
return spirv::groupShuffleDown<T>(spv::ScopeSubgroup, value, delta);
return spirv::groupNonUniformShuffleDown<T>(spv::ScopeSubgroup, value, delta);
}


Expand Down
Loading