Skip to content

Added support for multiple entrypoints for CLI yaml print #316

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 9 commits into
base: main
Choose a base branch
from
Open

Added support for multiple entrypoints for CLI yaml print #316

Show file tree
Hide file tree
Changes from 8 commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
be14602
Fixed all_interface_variables for multiple entrypoints
Luna5ama Jul 3, 2025
86fade4
Added support for multiple entrypoints for CLI yaml print
Luna5ama Jul 3, 2025
06f8a47
Removed older stuff that only works with 1 entrypoint from print yaml
Luna5ama Jul 3, 2025
f18bd04
Yaml print used descriptor binding index
Luna5ama Jul 3, 2025
393bb57
Fixed missing type descriptions from other entrypoints
Luna5ama Jul 4, 2025
18cf482
Removed interface_variables printing because we only cared input and …
Luna5ama Jul 4, 2025
5c91c09
Regenerated golden yaml files
Luna5ama Jul 4, 2025
6b938b5
Renerated golden yaml on Linux
Luna5ama Jul 4, 2025
2adabda
Fixed used push constant index prefix
Luna5ama Jul 5, 2025
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
226 changes: 159 additions & 67 deletions common/output_stream.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2183,6 +2183,9 @@ void SpvReflectToYaml::Write(std::ostream& os) {
const std::string t1 = Indent(indent_level + 1);
const std::string t2 = Indent(indent_level + 2);
const std::string t3 = Indent(indent_level + 3);
const std::string t4 = Indent(indent_level + 4);
const std::string t5 = Indent(indent_level + 5);
const std::string t6 = Indent(indent_level + 6);

os << "%YAML 1.1" << std::endl;
os << "---" << std::endl;
Expand All @@ -2206,11 +2209,14 @@ void SpvReflectToYaml::Write(std::ostream& os) {
for (uint32_t i = 0; i < sm_.push_constant_block_count; ++i) {
WriteBlockVariableTypes(os, sm_.push_constant_blocks[i], indent_level + 1);
}
for (uint32_t i = 0; i < sm_.input_variable_count; ++i) {
WriteInterfaceVariableTypes(os, *sm_.input_variables[i], indent_level + 1);
}
for (uint32_t i = 0; i < sm_.output_variable_count; ++i) {
WriteInterfaceVariableTypes(os, *sm_.output_variables[i], indent_level + 1);
for (uint32_t i_ep = 0; i_ep < sm_.entry_point_count; ++i_ep) {
const auto& ep = sm_.entry_points[i_ep];
for (uint32_t i = 0; i < ep.input_variable_count; ++i) {
WriteInterfaceVariableTypes(os, *ep.input_variables[i], indent_level + 1);
}
for (uint32_t i = 0; i < ep.output_variable_count; ++i) {
WriteInterfaceVariableTypes(os, *ep.output_variables[i], indent_level + 1);
}
}
}

Expand All @@ -2229,13 +2235,35 @@ void SpvReflectToYaml::Write(std::ostream& os) {
WriteDescriptorBinding(os, sm_.descriptor_bindings[i], indent_level + 1);
}

os << t0 << "all_descriptor_sets:" << std::endl;
for (uint32_t i_set = 0; i_set < sm_.descriptor_set_count; ++i_set) {
// typedef struct SpvReflectDescriptorSet {
const auto& dset = sm_.descriptor_sets[i_set];
// uint32_t set;
os << t1 << "- "
<< "set: " << dset.set << std::endl;
// uint32_t binding_count;
os << t2 << "binding_count: " << dset.binding_count << std::endl;
// SpvReflectDescriptorBinding** bindings;
os << t2 << "bindings:" << std::endl;
for (uint32_t i_binding = 0; i_binding < dset.binding_count; ++i_binding) {
auto itor = descriptor_binding_to_index_.find(dset.bindings[i_binding]);
assert(itor != descriptor_binding_to_index_.end());
os << t3 << "- *db" << itor->second << " # " << SafeString(dset.bindings[i_binding]->name) << std::endl;
}
// } SpvReflectDescriptorSet;
}

interface_variable_to_index_.clear();
os << t0 << "all_interface_variables:" << std::endl;
for (uint32_t i = 0; i < sm_.input_variable_count; ++i) {
WriteInterfaceVariable(os, *sm_.input_variables[i], indent_level + 1);
}
for (uint32_t i = 0; i < sm_.output_variable_count; ++i) {
WriteInterfaceVariable(os, *sm_.output_variables[i], indent_level + 1);
for (uint32_t i_ep = 0; i_ep < sm_.entry_point_count; ++i_ep) {
const auto& ep = sm_.entry_points[i_ep];
for (uint32_t i = 0; i < ep.input_variable_count; ++i) {
WriteInterfaceVariable(os, *ep.input_variables[i], indent_level + 1);
}
for (uint32_t i = 0; i < ep.output_variable_count; ++i) {
WriteInterfaceVariable(os, *ep.output_variables[i], indent_level + 1);
}
}

// struct SpvReflectShaderModule {
Expand All @@ -2246,6 +2274,127 @@ void SpvReflectToYaml::Write(std::ostream& os) {
os << t1 << "entry_point_name: " << SafeString(sm_.entry_point_name) << std::endl;
// uint32_t entry_point_id;
os << t1 << "entry_point_id: " << sm_.entry_point_id << std::endl;
// uint32_t entry_point_count;
os << t1 << "entry_point_count: " << sm_.entry_point_count << std::endl;
// SpvReflectEntryPoint* entry_points;
os << t1 << "entry_points:" << std::endl;
for (uint32_t i = 0; i < sm_.entry_point_count; ++i) {
// typedef struct SpvReflectEntryPoint {
const auto& ep = sm_.entry_points[i];
// const char* name;
os << t2 << "- name: " << SafeString(ep.name) << std::endl;
// uint32_t id;
os << t3 << "id: " << ep.id << std::endl;

// SpvExecutionModel spirv_execution_model;
os << t3 << "spirv_execution_model: " << ep.spirv_execution_model << " # "
<< ToStringSpvExecutionModel(ep.spirv_execution_model) << std::endl;
// SpvReflectShaderStageFlagBits shader_stage;
os << t3 << "shader_stage: " << AsHexString(ep.shader_stage) << " # " << ToStringShaderStage(ep.shader_stage) << std::endl;

// uint32_t input_variable_count;
os << t3 << "input_variable_count: " << ep.input_variable_count << std::endl;
// SpvReflectInterfaceVariable** input_variables;
os << t3 << "input_variables:" << std::endl;
for (uint32_t i_iv = 0; i_iv < ep.input_variable_count; ++i_iv) {
auto itor = interface_variable_to_index_.find(ep.input_variables[i_iv]);
assert(itor != interface_variable_to_index_.end());
os << t4 << "- *iv" << itor->second << " # " << SafeString(ep.input_variables[i_iv]->name) << std::endl;
}
// uint32_t output_variable_count;
os << t3 << "output_variable_count: " << ep.output_variable_count << std::endl;
// SpvReflectInterfaceVariable** output_variables;
os << t3 << "output_variables:" << std::endl;
for (uint32_t i_iv = 0; i_iv < ep.output_variable_count; ++i_iv) {
auto itor = interface_variable_to_index_.find(ep.output_variables[i_iv]);
assert(itor != interface_variable_to_index_.end());
os << t4 << "- *iv" << itor->second << " # " << SafeString(ep.output_variables[i_iv]->name) << std::endl;
}
// uint32_t descriptor_set_count;
os << t3 << "descriptor_set_count: " << ep.descriptor_set_count << std::endl;
// SpvReflectDescriptorSet* descriptor_sets;
os << t3 << "descriptor_sets:" << std::endl;
for (uint32_t i_set = 0; i_set < ep.descriptor_set_count; ++i_set) {
// struct SpvReflectDescriptorSet {
const auto& dset = ep.descriptor_sets[i_set];
// uint32_t set;
os << t4 << "- set: " << dset.set << std::endl;
// uint32_t binding_count;
os << t5 << "binding_count: " << dset.binding_count << std::endl;
// SpvReflectDescriptorBinding** bindings;
os << t5 << "bindings:" << std::endl;
// for (uint32_t i_binding = 0; i_binding < dset.binding_count; ++i_binding) {
for (uint32_t i_binding = 0; i_binding < dset.binding_count; ++i_binding) {
auto itor = descriptor_binding_to_index_.find(dset.bindings[i_binding]);
assert(itor != descriptor_binding_to_index_.end());
os << t6 << "- *db" << itor->second << " # " << SafeString(dset.bindings[i_binding]->name) << std::endl;
}
// } SpvReflectDescriptorSet;
}

// uint32_t used_descriptor_binding_count;
os << t3 << "used_descriptor_binding_count: " << ep.used_descriptor_binding_count << std::endl;
// uint32_t* used_descriptor_bindings;
os << t3 << "used_descriptor_bindings:" << std::endl;
for (uint32_t i_udb = 0; i_udb < ep.used_descriptor_binding_count; ++i_udb) {
const SpvReflectDescriptorBinding* found_db = nullptr;
for (uint32_t i_ds = 0; i_ds < sm_.descriptor_binding_count; ++i_ds) {
if (sm_.descriptor_bindings[i_ds].spirv_id == ep.used_descriptor_bindings[i_udb]) {
found_db = &sm_.descriptor_bindings[i_ds];
break;
}
}
assert(found_db);
auto itor = descriptor_binding_to_index_.find(found_db);
os << t4 << "- *db" << itor->second << " # " << SafeString(found_db->name) << std::endl;
}

// uint32_t used_push_constant_block_count;
os << t3 << "used_push_constant_block_count: " << ep.used_push_constant_block_count << std::endl;
// uint32_t* used_push_constant_blocks;
os << t3 << "used_push_constant_blocks:" << std::endl;
for (uint32_t i_pc = 0; i_pc < ep.used_push_constant_block_count; ++i_pc) {
const SpvReflectBlockVariable* found_bv = nullptr;
for (uint32_t i_bv = 0; i_bv < sm_.push_constant_block_count; ++i_bv) {
if (sm_.push_constant_blocks[i_bv].spirv_id == ep.used_push_constant_blocks[i_pc]) {
found_bv = &sm_.push_constant_blocks[i_bv];
break;
}
}
assert(found_bv);
auto itor = block_variable_to_index_.find(found_bv);
assert(itor != block_variable_to_index_.end());
os << t4 << "- *db" << itor->second << " # " << SafeString(found_bv->name) << std::endl;
}

// uint32_t execution_mode_count;
os << t3 << "execution_mode_count: " << ep.execution_mode_count << std::endl;
// SpvExecutionMode* execution_modes;
os << t3 << "execution_modes: [";
for (uint32_t i_em = 0; i_em < ep.execution_mode_count; ++i_em) {
if (i_em > 0) {
os << ", ";
}
os << ep.execution_modes[i_em];
}
os << "]" << std::endl;

// struct LocalSize {
os << t3 << "local_size: [";
// uint32_t x;
os << ep.local_size.x << ", ";
// uint32_t y;
os << ep.local_size.y << ", ";
// uint32_t z;
os << ep.local_size.z;
os << "]" << std::endl;

// uint32_t invocations; // valid for geometry
os << t3 << "invocations: " << ep.invocations << std::endl;
// uint32_t output_vertices; // valid for geometry, tesselation
os << t3 << "output_vertices: " << ep.output_vertices << std::endl;
// } SpvReflectEntryPoint;
}
// SpvSourceLanguage source_language;
os << t1 << "source_language: " << sm_.source_language << " # " << ToStringSpvSourceLanguage(sm_.source_language) << std::endl;
// uint32_t source_language_version;
Expand All @@ -2255,63 +2404,6 @@ void SpvReflectToYaml::Write(std::ostream& os) {
<< ToStringSpvExecutionModel(sm_.spirv_execution_model) << std::endl;
// SpvShaderStageFlagBits shader_stage;
os << t1 << "shader_stage: " << AsHexString(sm_.shader_stage) << " # " << ToStringShaderStage(sm_.shader_stage) << std::endl;
// uint32_t descriptor_binding_count;
os << t1 << "descriptor_binding_count: " << sm_.descriptor_binding_count << std::endl;
// SpvReflectDescriptorBinding* descriptor_bindings;
os << t1 << "descriptor_bindings:" << std::endl;
for (uint32_t i = 0; i < sm_.descriptor_binding_count; ++i) {
auto itor = descriptor_binding_to_index_.find(&sm_.descriptor_bindings[i]);
assert(itor != descriptor_binding_to_index_.end());
os << t2 << "- *db" << itor->second << " # " << SafeString(sm_.descriptor_bindings[i].name) << std::endl;
}
// uint32_t descriptor_set_count;
os << t1 << "descriptor_set_count: " << sm_.descriptor_set_count << std::endl;
// SpvReflectDescriptorSet descriptor_sets[SPV_REFLECT_MAX_DESCRIPTOR_SETS];
os << t1 << "descriptor_sets:" << std::endl;
for (uint32_t i_set = 0; i_set < sm_.descriptor_set_count; ++i_set) {
// typedef struct SpvReflectDescriptorSet {
const auto& dset = sm_.descriptor_sets[i_set];
// uint32_t set;
os << t1 << "- "
<< "set: " << dset.set << std::endl;
// uint32_t binding_count;
os << t2 << "binding_count: " << dset.binding_count << std::endl;
// SpvReflectDescriptorBinding** bindings;
os << t2 << "bindings:" << std::endl;
for (uint32_t i_binding = 0; i_binding < dset.binding_count; ++i_binding) {
auto itor = descriptor_binding_to_index_.find(dset.bindings[i_binding]);
assert(itor != descriptor_binding_to_index_.end());
os << t3 << "- *db" << itor->second << " # " << SafeString(dset.bindings[i_binding]->name) << std::endl;
}
// } SpvReflectDescriptorSet;
}
// uint32_t input_variable_count;
os << t1 << "input_variable_count: " << sm_.input_variable_count << ",\n";
// SpvReflectInterfaceVariable* input_variables;
os << t1 << "input_variables:" << std::endl;
for (uint32_t i = 0; i < sm_.input_variable_count; ++i) {
auto itor = interface_variable_to_index_.find(sm_.input_variables[i]);
assert(itor != interface_variable_to_index_.end());
os << t2 << "- *iv" << itor->second << " # " << SafeString(sm_.input_variables[i]->name) << std::endl;
}
// uint32_t output_variable_count;
os << t1 << "output_variable_count: " << sm_.output_variable_count << ",\n";
// SpvReflectInterfaceVariable* output_variables;
os << t1 << "output_variables:" << std::endl;
for (uint32_t i = 0; i < sm_.output_variable_count; ++i) {
auto itor = interface_variable_to_index_.find(sm_.output_variables[i]);
assert(itor != interface_variable_to_index_.end());
os << t2 << "- *iv" << itor->second << " # " << SafeString(sm_.output_variables[i]->name) << std::endl;
}
// uint32_t push_constant_count;
os << t1 << "push_constant_count: " << sm_.push_constant_block_count << ",\n";
// SpvReflectBlockVariable* push_constants;
os << t1 << "push_constants:" << std::endl;
for (uint32_t i = 0; i < sm_.push_constant_block_count; ++i) {
auto itor = block_variable_to_index_.find(&sm_.push_constant_blocks[i]);
assert(itor != block_variable_to_index_.end());
os << t2 << "- *bv" << itor->second << " # " << SafeString(sm_.push_constant_blocks[i].name) << std::endl;
}

// uint32_t spec_constant_count;
os << t1 << "specialization_constant_count: " << sm_.spec_constant_count << ",\n";
Expand Down
Loading
Loading