AuroraMiddleware/SPIRV-Cross
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6fcf8c83d9
SPIRV-Cross/spirv_cross_parsed_ir.cpp

752 lines
17 KiB
C++
Raw Normal View History

Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
/*
Nonfunctional: Update copyright headers for 2019.
2019-01-04 11:38:35 +00:00
* Copyright 2018-2019 Arm Limited
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "spirv_cross_parsed_ir.hpp"
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
#include <algorithm>
Run format_all.sh.
2019-01-11 11:56:00 +00:00
#include <assert.h>
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
using namespace std;
using namespace spv;
Add an option to override the namespace used for spirv_cross. This is a pragmatic trick to avoid symbol collision where a project links against SPIRV-Cross statically, while linking to other projects which also use SPIRV-Cross statically. We can end up with very awkward symbol collisions which can resolve themselves silently because SPIRV-Cross is pulled in as necessary. To fix this, we must use different symbols and embed two copies of SPIRV-Cross in this scenario, now with different namespaces, which in turn leads to different symbols.
2019-03-29 09:29:44 +00:00
namespace SPIRV_CROSS_NAMESPACE
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
{
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
ParsedIR::ParsedIR()
{
// If we move ParsedIR, we need to make sure the pointer stays fixed since the child Variant objects consume a pointer to this group,
// so need an extra pointer here.
pool_group.reset(new ObjectPoolGroup);
pool_group->pools[TypeType].reset(new ObjectPool<SPIRType>);
pool_group->pools[TypeVariable].reset(new ObjectPool<SPIRVariable>);
pool_group->pools[TypeConstant].reset(new ObjectPool<SPIRConstant>);
pool_group->pools[TypeFunction].reset(new ObjectPool<SPIRFunction>);
pool_group->pools[TypeFunctionPrototype].reset(new ObjectPool<SPIRFunctionPrototype>);
pool_group->pools[TypeBlock].reset(new ObjectPool<SPIRBlock>);
pool_group->pools[TypeExtension].reset(new ObjectPool<SPIRExtension>);
pool_group->pools[TypeExpression].reset(new ObjectPool<SPIRExpression>);
pool_group->pools[TypeConstantOp].reset(new ObjectPool<SPIRConstantOp>);
pool_group->pools[TypeCombinedImageSampler].reset(new ObjectPool<SPIRCombinedImageSampler>);
pool_group->pools[TypeAccessChain].reset(new ObjectPool<SPIRAccessChain>);
pool_group->pools[TypeUndef].reset(new ObjectPool<SPIRUndef>);
}
Explicitly implement move operators for ParsedIR. Workaround for MSVC 2013.
2019-04-09 08:25:41 +00:00
// Should have been default-implemented, but need this on MSVC 2013.
ParsedIR::ParsedIR(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT
{
*this = move(other);
}
ParsedIR &ParsedIR::operator=(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT
{
if (this != &other)
{
Fix various bugs found in testing.
2019-04-09 08:54:28 +00:00
pool_group = move(other.pool_group);
Explicitly implement move operators for ParsedIR. Workaround for MSVC 2013.
2019-04-09 08:25:41 +00:00
spirv = move(other.spirv);
meta = move(other.meta);
for (int i = 0; i < TypeCount; i++)
Make sure ids_for_types are moved correctly in move operator.
2019-04-09 13:16:37 +00:00
ids_for_type[i] = move(other.ids_for_type[i]);
Explicitly implement move operators for ParsedIR. Workaround for MSVC 2013.
2019-04-09 08:25:41 +00:00
ids_for_constant_or_type = move(other.ids_for_constant_or_type);
ids_for_constant_or_variable = move(other.ids_for_constant_or_variable);
declared_capabilities = move(other.declared_capabilities);
declared_extensions = move(other.declared_extensions);
block_meta = move(other.block_meta);
continue_block_to_loop_header = move(other.continue_block_to_loop_header);
entry_points = move(other.entry_points);
ids = move(other.ids);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
addressing_model = other.addressing_model;
memory_model = other.memory_model;
Make sure ids_for_types are moved correctly in move operator.
2019-04-09 13:16:37 +00:00
default_entry_point = other.default_entry_point;
source = other.source;
loop_iteration_depth = other.loop_iteration_depth;
Explicitly implement move operators for ParsedIR. Workaround for MSVC 2013.
2019-04-09 08:25:41 +00:00
}
return *this;
}
Make sure ids_for_types are moved correctly in move operator.
2019-04-09 13:16:37 +00:00
ParsedIR::ParsedIR(const ParsedIR &other)
: ParsedIR()
{
*this = other;
}
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
ParsedIR &ParsedIR::operator=(const ParsedIR &other)
{
if (this != &other)
{
spirv = other.spirv;
meta = other.meta;
for (int i = 0; i < TypeCount; i++)
ids_for_type[i] = other.ids_for_type[i];
ids_for_constant_or_type = other.ids_for_constant_or_type;
ids_for_constant_or_variable = other.ids_for_constant_or_variable;
declared_capabilities = other.declared_capabilities;
declared_extensions = other.declared_extensions;
block_meta = other.block_meta;
continue_block_to_loop_header = other.continue_block_to_loop_header;
entry_points = other.entry_points;
default_entry_point = other.default_entry_point;
source = other.source;
loop_iteration_depth = other.loop_iteration_depth;
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
addressing_model = other.addressing_model;
memory_model = other.memory_model;
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
// Very deliberate copying of IDs. There is no default copy constructor, nor a simple default constructor.
// Construct object first so we have the correct allocator set-up, then we can copy object into our new pool group.
ids.clear();
ids.reserve(other.ids.size());
for (size_t i = 0; i < other.ids.size(); i++)
{
ids.emplace_back(pool_group.get());
ids.back() = other.ids[i];
}
}
return *this;
}
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
void ParsedIR::set_id_bounds(uint32_t bounds)
{
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
ids.reserve(bounds);
while (ids.size() < bounds)
ids.emplace_back(pool_group.get());
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
block_meta.resize(bounds);
}
static string ensure_valid_identifier(const string &name, bool member)
{
// Functions in glslangValidator are mangled with name(<mangled> stuff.
// Normally, we would never see '(' in any legal identifiers, so just strip them out.
auto str = name.substr(0, name.find('('));
for (uint32_t i = 0; i < str.size(); i++)
{
auto &c = str[i];
if (member)
{
// _m<num> variables are reserved by the internal implementation,
// otherwise, make sure the name is a valid identifier.
if (i == 0)
c = isalpha(c) ? c : '_';
else if (i == 2 && str[0] == '_' && str[1] == 'm')
c = isalpha(c) ? c : '_';
else
c = isalnum(c) ? c : '_';
}
else
{
// _<num> variables are reserved by the internal implementation,
// otherwise, make sure the name is a valid identifier.
if (i == 0 || (str[0] == '_' && i == 1))
c = isalpha(c) ? c : '_';
else
c = isalnum(c) ? c : '_';
}
}
return str;
}
const string &ParsedIR::get_name(uint32_t id) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (m)
return m->decoration.alias;
else
return empty_string;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
const string &ParsedIR::get_member_name(uint32_t id, uint32_t index) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (m)
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
if (index >= m->members.size())
return empty_string;
return m->members[index].alias;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
else
return empty_string;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
void ParsedIR::set_name(uint32_t id, const string &name)
{
auto &str = meta[id].decoration.alias;
str.clear();
if (name.empty())
return;
// Reserved for temporaries.
if (name[0] == '_' && name.size() >= 2 && isdigit(name[1]))
return;
str = ensure_valid_identifier(name, false);
}
void ParsedIR::set_member_name(uint32_t id, uint32_t index, const string &name)
{
meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
auto &str = meta[id].members[index].alias;
str.clear();
if (name.empty())
return;
// Reserved for unnamed members.
if (name[0] == '_' && name.size() >= 3 && name[1] == 'm' && isdigit(name[2]))
return;
str = ensure_valid_identifier(name, true);
}
void ParsedIR::set_decoration_string(uint32_t id, Decoration decoration, const string &argument)
{
auto &dec = meta[id].decoration;
dec.decoration_flags.set(decoration);
switch (decoration)
{
case DecorationHlslSemanticGOOGLE:
dec.hlsl_semantic = argument;
break;
default:
break;
}
}
void ParsedIR::set_decoration(uint32_t id, Decoration decoration, uint32_t argument)
{
auto &dec = meta[id].decoration;
dec.decoration_flags.set(decoration);
switch (decoration)
{
case DecorationBuiltIn:
dec.builtin = true;
dec.builtin_type = static_cast<BuiltIn>(argument);
break;
case DecorationLocation:
dec.location = argument;
break;
case DecorationComponent:
dec.component = argument;
break;
case DecorationOffset:
dec.offset = argument;
break;
case DecorationArrayStride:
dec.array_stride = argument;
break;
case DecorationMatrixStride:
dec.matrix_stride = argument;
break;
case DecorationBinding:
dec.binding = argument;
break;
case DecorationDescriptorSet:
dec.set = argument;
break;
case DecorationInputAttachmentIndex:
dec.input_attachment = argument;
break;
case DecorationSpecId:
dec.spec_id = argument;
break;
case DecorationIndex:
dec.index = argument;
break;
case DecorationHlslCounterBufferGOOGLE:
meta[id].hlsl_magic_counter_buffer = argument;
Remove old hack for dealing with HLSL counter buffers. No longer needed.
2018-11-22 09:23:58 +00:00
meta[argument].hlsl_is_magic_counter_buffer = true;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
break;
Handle FPRoundingMode decoration. Doesn't do anything, but we can parse it correctly for now.
2019-01-07 09:51:44 +00:00
case DecorationFPRoundingMode:
dec.fp_rounding_mode = static_cast<FPRoundingMode>(argument);
break;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
default:
break;
}
}
void ParsedIR::set_member_decoration(uint32_t id, uint32_t index, Decoration decoration, uint32_t argument)
{
meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
auto &dec = meta[id].members[index];
dec.decoration_flags.set(decoration);
switch (decoration)
{
case DecorationBuiltIn:
dec.builtin = true;
dec.builtin_type = static_cast<BuiltIn>(argument);
break;
case DecorationLocation:
dec.location = argument;
break;
case DecorationComponent:
dec.component = argument;
break;
case DecorationBinding:
dec.binding = argument;
break;
case DecorationOffset:
dec.offset = argument;
break;
case DecorationSpecId:
dec.spec_id = argument;
break;
case DecorationMatrixStride:
dec.matrix_stride = argument;
break;
case DecorationIndex:
dec.index = argument;
break;
default:
break;
}
}
// Recursively marks any constants referenced by the specified constant instruction as being used
// as an array length. The id must be a constant instruction (SPIRConstant or SPIRConstantOp).
void ParsedIR::mark_used_as_array_length(uint32_t id)
{
switch (ids[id].get_type())
{
case TypeConstant:
get<SPIRConstant>(id).is_used_as_array_length = true;
break;
case TypeConstantOp:
{
auto &cop = get<SPIRConstantOp>(id);
for (uint32_t arg_id : cop.arguments)
mark_used_as_array_length(arg_id);
break;
}
case TypeUndef:
break;
default:
assert(0);
}
}
Bitset ParsedIR::get_buffer_block_flags(const SPIRVariable &var) const
{
auto &type = get<SPIRType>(var.basetype);
assert(type.basetype == SPIRType::Struct);
// Some flags like non-writable, non-readable are actually found
// as member decorations. If all members have a decoration set, propagate
// the decoration up as a regular variable decoration.
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
Bitset base_flags;
auto *m = find_meta(var.self);
if (m)
base_flags = m->decoration.decoration_flags;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (type.member_types.empty())
return base_flags;
Bitset all_members_flags = get_member_decoration_bitset(type.self, 0);
for (uint32_t i = 1; i < uint32_t(type.member_types.size()); i++)
all_members_flags.merge_and(get_member_decoration_bitset(type.self, i));
base_flags.merge_or(all_members_flags);
return base_flags;
}
const Bitset &ParsedIR::get_member_decoration_bitset(uint32_t id, uint32_t index) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (m)
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
if (index >= m->members.size())
return cleared_bitset;
return m->members[index].decoration_flags;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
else
return cleared_bitset;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
bool ParsedIR::has_decoration(uint32_t id, Decoration decoration) const
{
return get_decoration_bitset(id).get(decoration);
}
uint32_t ParsedIR::get_decoration(uint32_t id, Decoration decoration) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (!m)
return 0;
auto &dec = m->decoration;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (!dec.decoration_flags.get(decoration))
return 0;
switch (decoration)
{
case DecorationBuiltIn:
return dec.builtin_type;
case DecorationLocation:
return dec.location;
case DecorationComponent:
return dec.component;
case DecorationOffset:
return dec.offset;
case DecorationBinding:
return dec.binding;
case DecorationDescriptorSet:
return dec.set;
case DecorationInputAttachmentIndex:
return dec.input_attachment;
case DecorationSpecId:
return dec.spec_id;
case DecorationArrayStride:
return dec.array_stride;
case DecorationMatrixStride:
return dec.matrix_stride;
case DecorationIndex:
return dec.index;
Handle FPRoundingMode decoration. Doesn't do anything, but we can parse it correctly for now.
2019-01-07 09:51:44 +00:00
case DecorationFPRoundingMode:
return dec.fp_rounding_mode;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
default:
return 1;
}
}
const string &ParsedIR::get_decoration_string(uint32_t id, Decoration decoration) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (!m)
return empty_string;
auto &dec = m->decoration;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (!dec.decoration_flags.get(decoration))
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
return empty_string;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
switch (decoration)
{
case DecorationHlslSemanticGOOGLE:
return dec.hlsl_semantic;
default:
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
return empty_string;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
}
void ParsedIR::unset_decoration(uint32_t id, Decoration decoration)
{
auto &dec = meta[id].decoration;
dec.decoration_flags.clear(decoration);
switch (decoration)
{
case DecorationBuiltIn:
dec.builtin = false;
break;
case DecorationLocation:
dec.location = 0;
break;
case DecorationComponent:
dec.component = 0;
break;
case DecorationOffset:
dec.offset = 0;
break;
case DecorationBinding:
dec.binding = 0;
break;
case DecorationDescriptorSet:
dec.set = 0;
break;
case DecorationInputAttachmentIndex:
dec.input_attachment = 0;
break;
case DecorationSpecId:
dec.spec_id = 0;
break;
case DecorationHlslSemanticGOOGLE:
dec.hlsl_semantic.clear();
break;
Handle FPRoundingMode decoration. Doesn't do anything, but we can parse it correctly for now.
2019-01-07 09:51:44 +00:00
case DecorationFPRoundingMode:
dec.fp_rounding_mode = FPRoundingModeMax;
break;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
case DecorationHlslCounterBufferGOOGLE:
{
auto &counter = meta[id].hlsl_magic_counter_buffer;
if (counter)
{
meta[counter].hlsl_is_magic_counter_buffer = false;
counter = 0;
}
break;
}
default:
break;
}
}
bool ParsedIR::has_member_decoration(uint32_t id, uint32_t index, Decoration decoration) const
{
return get_member_decoration_bitset(id, index).get(decoration);
}
uint32_t ParsedIR::get_member_decoration(uint32_t id, uint32_t index, Decoration decoration) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (!m)
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
return 0;
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
if (index >= m->members.size())
return 0;
auto &dec = m->members[index];
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (!dec.decoration_flags.get(decoration))
return 0;
switch (decoration)
{
case DecorationBuiltIn:
return dec.builtin_type;
case DecorationLocation:
return dec.location;
case DecorationComponent:
return dec.component;
case DecorationBinding:
return dec.binding;
case DecorationOffset:
return dec.offset;
case DecorationSpecId:
return dec.spec_id;
case DecorationIndex:
return dec.index;
default:
return 1;
}
}
const Bitset &ParsedIR::get_decoration_bitset(uint32_t id) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (m)
{
auto &dec = m->decoration;
return dec.decoration_flags;
}
else
return cleared_bitset;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
void ParsedIR::set_member_decoration_string(uint32_t id, uint32_t index, Decoration decoration, const string &argument)
{
meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
auto &dec = meta[id].members[index];
dec.decoration_flags.set(decoration);
switch (decoration)
{
case DecorationHlslSemanticGOOGLE:
dec.hlsl_semantic = argument;
break;
default:
break;
}
}
const string &ParsedIR::get_member_decoration_string(uint32_t id, uint32_t index, Decoration decoration) const
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = find_meta(id);
if (m)
{
if (!has_member_decoration(id, index, decoration))
return empty_string;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto &dec = m->members[index];
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
switch (decoration)
{
case DecorationHlslSemanticGOOGLE:
return dec.hlsl_semantic;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
default:
return empty_string;
}
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
else
return empty_string;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
}
void ParsedIR::unset_member_decoration(uint32_t id, uint32_t index, Decoration decoration)
{
auto &m = meta[id];
if (index >= m.members.size())
return;
auto &dec = m.members[index];
dec.decoration_flags.clear(decoration);
switch (decoration)
{
case DecorationBuiltIn:
dec.builtin = false;
break;
case DecorationLocation:
dec.location = 0;
break;
case DecorationComponent:
dec.component = 0;
break;
case DecorationOffset:
dec.offset = 0;
break;
case DecorationSpecId:
dec.spec_id = 0;
break;
case DecorationHlslSemanticGOOGLE:
dec.hlsl_semantic.clear();
break;
default:
break;
}
}
uint32_t ParsedIR::increase_bound_by(uint32_t incr_amount)
{
auto curr_bound = ids.size();
auto new_bound = curr_bound + incr_amount;
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
ids.reserve(ids.size() + incr_amount);
for (uint32_t i = 0; i < incr_amount; i++)
ids.emplace_back(pool_group.get());
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
block_meta.resize(new_bound);
return uint32_t(curr_bound);
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
void ParsedIR::remove_typed_id(Types type, uint32_t id)
{
auto &type_ids = ids_for_type[type];
type_ids.erase(remove(begin(type_ids), end(type_ids), id), end(type_ids));
}
void ParsedIR::reset_all_of_type(Types type)
{
for (auto &id : ids_for_type[type])
if (ids[id].get_type() == type)
ids[id].reset();
ids_for_type[type].clear();
}
void ParsedIR::add_typed_id(Types type, uint32_t id)
{
if (loop_iteration_depth)
SPIRV_CROSS_THROW("Cannot add typed ID while looping over it.");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (ids[id].empty() || ids[id].get_type() != type)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
{
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
switch (type)
{
case TypeConstant:
ids_for_constant_or_variable.push_back(id);
ids_for_constant_or_type.push_back(id);
break;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
case TypeVariable:
ids_for_constant_or_variable.push_back(id);
break;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
case TypeType:
case TypeConstantOp:
ids_for_constant_or_type.push_back(id);
break;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
default:
break;
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
}
if (ids[id].empty())
{
ids_for_type[type].push_back(id);
}
else if (ids[id].get_type() != type)
{
remove_typed_id(ids[id].get_type(), id);
ids_for_type[type].push_back(id);
}
}
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
const Meta *ParsedIR::find_meta(uint32_t id) const
{
auto itr = meta.find(id);
if (itr != end(meta))
return &itr->second;
else
return nullptr;
}
Meta *ParsedIR::find_meta(uint32_t id)
{
auto itr = meta.find(id);
if (itr != end(meta))
return &itr->second;
else
return nullptr;
}
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
} // namespace SPIRV_CROSS_NAMESPACE
Reference in New Issue Copy Permalink