To improve cache hits when matching SPIRVToMSLConversionConfiguration structs
to each other to find cached shader, only consider current shader stage resources.
Rename more references to ShaderConverterContext to ShaderConversionConfig.
diff --git a/Docs/Whats_New.md b/Docs/Whats_New.md
index 73f3dc1..da7173d 100644
--- a/Docs/Whats_New.md
+++ b/Docs/Whats_New.md
@@ -22,6 +22,8 @@
- Expose `vkGetIOSurfaceMVK()` and `vkUseIOSurfaceMVK()` without requiring _Objective-C_.
- Support _Xcode 12.5_ build settings, build warnings, and SDK change to availability of
`[MTLDevice supportsBCTextureCompression]` on _Mac Catalyst_.
+- Improve cache hits when matching `SPIRVToMSLConversionConfiguration` structs to each other
+ to find a cached shader, by only considering resources from the current shader stage.
- Rename `kMVKShaderStageMax` to `kMVKShaderStageCount`.
- Fix internal reference from `SPIRV_CROSS_NAMESPACE_OVERRIDE` to `SPIRV_CROSS_NAMESPACE`.
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
index 6935de0..0f69331 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
@@ -198,7 +198,7 @@
void propagateDebugName() override {}
template<typename CreateInfo> void addMTLArgumentEncoders(MVKMTLFunction& mvkMTLFunc,
const CreateInfo* pCreateInfo,
- SPIRVToMSLConversionConfiguration& context,
+ SPIRVToMSLConversionConfiguration& shaderConfig,
MVKShaderStage stage);
MVKPipelineCache* _pipelineCache;
@@ -468,7 +468,7 @@
*/
VkResult writeData(size_t* pDataSize, void* pData);
- /** Return a shader library from the specified shader context sourced from the specified shader module. */
+ /** Return a shader library from the shader conversion configuration and sourced from the specified shader module. */
MVKShaderLibrary* getShaderLibrary(SPIRVToMSLConversionConfiguration* pContext, MVKShaderModule* shaderModule);
/** Merges the contents of the specified number of pipeline caches into this cache. */
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
index 9233137..6cf3d3b 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
@@ -187,7 +187,7 @@
template<typename CreateInfo>
void MVKPipeline::addMTLArgumentEncoders(MVKMTLFunction& mvkMTLFunc,
const CreateInfo* pCreateInfo,
- SPIRVToMSLConversionConfiguration& context,
+ SPIRVToMSLConversionConfiguration& shaderConfig,
MVKShaderStage stage) {
if ( !isUsingMetalArgumentBuffers() ) { return; }
@@ -195,7 +195,7 @@
auto mtlFunc = mvkMTLFunc.getMTLFunction();
for (uint32_t dsIdx = 0; dsIdx < _descriptorSetCount; dsIdx++) {
auto* dsLayout = ((MVKPipelineLayout*)pCreateInfo->layout)->getDescriptorSetLayout(dsIdx);
- bool descSetIsUsed = dsLayout->populateBindingUse(getDescriptorBindingUse(dsIdx, stage), context, stage, dsIdx);
+ bool descSetIsUsed = dsLayout->populateBindingUse(getDescriptorBindingUse(dsIdx, stage), shaderConfig, stage, dsIdx);
if (descSetIsUsed && needMTLArgEnc) {
getMTLArgumentEncoder(dsIdx, stage).init([mtlFunc newArgumentEncoderWithBufferIndex: dsIdx]);
}
@@ -1577,10 +1577,10 @@
shaderConfig.options.numTessControlPoints = reflectData.numControlPoints;
}
-// Initializes the vertex attributes in a shader converter context.
+// Initializes the vertex attributes in a shader conversion configuration.
void MVKGraphicsPipeline::addVertexInputToShaderConversionConfig(SPIRVToMSLConversionConfiguration& shaderConfig,
const VkGraphicsPipelineCreateInfo* pCreateInfo) {
- // Set the shader context vertex attribute information
+ // Set the shader conversion config vertex attribute information
shaderConfig.shaderInputs.clear();
uint32_t vaCnt = pCreateInfo->pVertexInputState->vertexAttributeDescriptionCount;
for (uint32_t vaIdx = 0; vaIdx < vaCnt; vaIdx++) {
@@ -1629,10 +1629,10 @@
}
}
-// Initializes the shader inputs in a shader converter context from the previous stage output.
+// Initializes the shader inputs in a shader conversion config from the previous stage output.
void MVKGraphicsPipeline::addPrevStageOutputToShaderConversionConfig(SPIRVToMSLConversionConfiguration& shaderConfig,
SPIRVShaderOutputs& shaderOutputs) {
- // Set the shader context input variable information
+ // Set the shader conversion configuration input variable information
shaderConfig.shaderInputs.clear();
uint32_t siCnt = (uint32_t)shaderOutputs.size();
for (uint32_t siIdx = 0; siIdx < siCnt; siIdx++) {
@@ -1828,7 +1828,7 @@
#pragma mark -
#pragma mark MVKPipelineCache
-// Return a shader library from the specified shader context sourced from the specified shader module.
+// Return a shader library from the specified shader conversion configuration sourced from the specified shader module.
MVKShaderLibrary* MVKPipelineCache::getShaderLibrary(SPIRVToMSLConversionConfiguration* pContext, MVKShaderModule* shaderModule) {
lock_guard<mutex> lock(_shaderCacheLock);
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.h b/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.h
index 1fa007e..e20aea6 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.h
@@ -128,13 +128,13 @@
MVKVulkanAPIObject* getVulkanAPIObject() override { return _owner->getVulkanAPIObject(); };
/**
- * Returns a shader library from the specified shader context sourced from the specified shader module,
+ * Returns a shader library from the shader conversion configuration sourced from the shader module,
* lazily creating the shader library from source code in the shader module, if needed.
*
* If pWasAdded is not nil, this function will set it to true if a new shader library was created,
* and to false if an existing shader library was found and returned.
*/
- MVKShaderLibrary* getShaderLibrary(SPIRVToMSLConversionConfiguration* pContext,
+ MVKShaderLibrary* getShaderLibrary(SPIRVToMSLConversionConfiguration* pShaderConfig,
MVKShaderModule* shaderModule,
bool* pWasAdded = nullptr);
@@ -147,8 +147,8 @@
friend MVKPipelineCache;
friend MVKShaderModule;
- MVKShaderLibrary* findShaderLibrary(SPIRVToMSLConversionConfiguration* pContext);
- MVKShaderLibrary* addShaderLibrary(SPIRVToMSLConversionConfiguration* pContext,
+ MVKShaderLibrary* findShaderLibrary(SPIRVToMSLConversionConfiguration* pShaderConfig);
+ MVKShaderLibrary* addShaderLibrary(SPIRVToMSLConversionConfiguration* pShaderConfig,
const std::string& mslSourceCode,
const SPIRVToMSLConversionResults& shaderConversionResults);
void merge(MVKShaderLibraryCache* other);
@@ -195,12 +195,12 @@
VkDebugReportObjectTypeEXT getVkDebugReportObjectType() override { return VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT; }
/** Returns the Metal shader function, possibly specialized. */
- MVKMTLFunction getMTLFunction(SPIRVToMSLConversionConfiguration* pContext,
+ MVKMTLFunction getMTLFunction(SPIRVToMSLConversionConfiguration* pShaderConfig,
const VkSpecializationInfo* pSpecializationInfo,
MVKPipelineCache* pipelineCache);
- /** Convert the SPIR-V to MSL, using the specified shader conversion context. */
- bool convert(SPIRVToMSLConversionConfiguration* pContext);
+ /** Convert the SPIR-V to MSL, using the specified shader conversion configuration. */
+ bool convert(SPIRVToMSLConversionConfiguration* pShaderConfig);
/** Returns the original SPIR-V code that was specified when this object was created. */
const std::vector<uint32_t>& getSPIRV() { return _spvConverter.getSPIRV(); }
@@ -228,7 +228,7 @@
friend MVKShaderCacheIterator;
void propagateDebugName() override {}
- MVKGLSLConversionShaderStage getMVKGLSLConversionShaderStage(SPIRVToMSLConversionConfiguration* pContext);
+ MVKGLSLConversionShaderStage getMVKGLSLConversionShaderStage(SPIRVToMSLConversionConfiguration* pShaderConfig);
MVKShaderLibraryCache _shaderLibraryCache;
SPIRVToMSLConverter _spvConverter;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.mm b/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.mm
index 732e4f3..7da3dca 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKShaderModule.mm
@@ -211,14 +211,14 @@
#pragma mark -
#pragma mark MVKShaderLibraryCache
-MVKShaderLibrary* MVKShaderLibraryCache::getShaderLibrary(SPIRVToMSLConversionConfiguration* pContext,
+MVKShaderLibrary* MVKShaderLibraryCache::getShaderLibrary(SPIRVToMSLConversionConfiguration* pShaderConfig,
MVKShaderModule* shaderModule,
bool* pWasAdded) {
bool wasAdded = false;
- MVKShaderLibrary* shLib = findShaderLibrary(pContext);
+ MVKShaderLibrary* shLib = findShaderLibrary(pShaderConfig);
if ( !shLib ) {
- if (shaderModule->convert(pContext)) {
- shLib = addShaderLibrary(pContext, shaderModule->getMSL(), shaderModule->getConversionResults());
+ if (shaderModule->convert(pShaderConfig)) {
+ shLib = addShaderLibrary(pShaderConfig, shaderModule->getMSL(), shaderModule->getConversionResults());
wasAdded = true;
}
}
@@ -228,24 +228,24 @@
return shLib;
}
-// Finds and returns a shader library matching the specified context, or returns nullptr if it doesn't exist.
-// If a match is found, the specified context is aligned with the context of the matching library.
-MVKShaderLibrary* MVKShaderLibraryCache::findShaderLibrary(SPIRVToMSLConversionConfiguration* pContext) {
+// Finds and returns a shader library matching the shader config, or returns nullptr if it doesn't exist.
+// If a match is found, the shader config is aligned with the shader config of the matching library.
+MVKShaderLibrary* MVKShaderLibraryCache::findShaderLibrary(SPIRVToMSLConversionConfiguration* pShaderConfig) {
for (auto& slPair : _shaderLibraries) {
- if (slPair.first.matches(*pContext)) {
- pContext->alignWith(slPair.first);
+ if (slPair.first.matches(*pShaderConfig)) {
+ pShaderConfig->alignWith(slPair.first);
return slPair.second;
}
}
return nullptr;
}
-// Adds and returns a new shader library configured from the specified context.
-MVKShaderLibrary* MVKShaderLibraryCache::addShaderLibrary(SPIRVToMSLConversionConfiguration* pContext,
+// Adds and returns a new shader library configured from the specified conversion configuration.
+MVKShaderLibrary* MVKShaderLibraryCache::addShaderLibrary(SPIRVToMSLConversionConfiguration* pShaderConfig,
const string& mslSourceCode,
const SPIRVToMSLConversionResults& shaderConversionResults) {
MVKShaderLibrary* shLib = new MVKShaderLibrary(_owner, mslSourceCode, shaderConversionResults);
- _shaderLibraries.emplace_back(*pContext, shLib);
+ _shaderLibraries.emplace_back(*pShaderConfig, shLib);
return shLib;
}
@@ -268,7 +268,7 @@
#pragma mark -
#pragma mark MVKShaderModule
-MVKMTLFunction MVKShaderModule::getMTLFunction(SPIRVToMSLConversionConfiguration* pContext,
+MVKMTLFunction MVKShaderModule::getMTLFunction(SPIRVToMSLConversionConfiguration* pShaderConfig,
const VkSpecializationInfo* pSpecializationInfo,
MVKPipelineCache* pipelineCache) {
lock_guard<mutex> lock(_accessLock);
@@ -277,20 +277,20 @@
if ( !mvkLib ) {
uint64_t startTime = _device->getPerformanceTimestamp();
if (pipelineCache) {
- mvkLib = pipelineCache->getShaderLibrary(pContext, this);
+ mvkLib = pipelineCache->getShaderLibrary(pShaderConfig, this);
} else {
- mvkLib = _shaderLibraryCache.getShaderLibrary(pContext, this);
+ mvkLib = _shaderLibraryCache.getShaderLibrary(pShaderConfig, this);
}
_device->addActivityPerformance(_device->_performanceStatistics.shaderCompilation.shaderLibraryFromCache, startTime);
} else {
- mvkLib->setEntryPointName(pContext->options.entryPointName);
- pContext->markAllInputsAndResourcesUsed();
+ mvkLib->setEntryPointName(pShaderConfig->options.entryPointName);
+ pShaderConfig->markAllInputsAndResourcesUsed();
}
return mvkLib ? mvkLib->getMTLFunction(pSpecializationInfo, this) : MVKMTLFunctionNull;
}
-bool MVKShaderModule::convert(SPIRVToMSLConversionConfiguration* pContext) {
+bool MVKShaderModule::convert(SPIRVToMSLConversionConfiguration* pShaderConfig) {
bool shouldLogCode = mvkConfig().debugMode;
bool shouldLogEstimatedGLSL = shouldLogCode;
@@ -299,7 +299,7 @@
if ( !_spvConverter.hasSPIRV() && _glslConverter.hasGLSL() ) {
uint64_t startTime = _device->getPerformanceTimestamp();
- bool wasConverted = _glslConverter.convert(getMVKGLSLConversionShaderStage(pContext), shouldLogCode, false);
+ bool wasConverted = _glslConverter.convert(getMVKGLSLConversionShaderStage(pShaderConfig), shouldLogCode, false);
_device->addActivityPerformance(_device->_performanceStatistics.shaderCompilation.glslToSPRIV, startTime);
if (wasConverted) {
@@ -312,7 +312,7 @@
}
uint64_t startTime = _device->getPerformanceTimestamp();
- bool wasConverted = _spvConverter.convert(*pContext, shouldLogCode, shouldLogCode, shouldLogEstimatedGLSL);
+ bool wasConverted = _spvConverter.convert(*pShaderConfig, shouldLogCode, shouldLogCode, shouldLogEstimatedGLSL);
_device->addActivityPerformance(_device->_performanceStatistics.shaderCompilation.spirvToMSL, startTime);
if (wasConverted) {
@@ -323,9 +323,9 @@
return wasConverted;
}
-// Returns the MVKGLSLConversionShaderStage corresponding to the shader stage in the SPIR-V converter context.
-MVKGLSLConversionShaderStage MVKShaderModule::getMVKGLSLConversionShaderStage(SPIRVToMSLConversionConfiguration* pContext) {
- switch (pContext->options.entryPointStage) {
+// Returns the MVKGLSLConversionShaderStage corresponding to the shader stage in the SPIR-V conversion configuration.
+MVKGLSLConversionShaderStage MVKShaderModule::getMVKGLSLConversionShaderStage(SPIRVToMSLConversionConfiguration* pShaderConfig) {
+ switch (pShaderConfig->options.entryPointStage) {
case spv::ExecutionModelVertex: return kMVKGLSLConversionShaderStageVertex;
case spv::ExecutionModelTessellationControl: return kMVKGLSLConversionShaderStageTessControl;
case spv::ExecutionModelTessellationEvaluation: return kMVKGLSLConversionShaderStageTessEval;
diff --git a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp
index b518e0f..17c7939 100644
--- a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp
+++ b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp
@@ -171,6 +171,11 @@
for (auto& rb : resourceBindings) { rb.outIsUsedByShader = true; }
}
+// A single SPIRVToMSLConversionConfiguration instance is used for all pipeline shader stages,
+// and the resources can be spread across these shader stages. To improve cache hits when using
+// this function to find a cached shader for a particular shader stage, only consider the resources
+// that are used in that shader stage. By contrast, discreteDescriptorSet apply across all stages,
+// and shaderInputs are populated before each stage, so neither needs to be filtered by stage here.
MVK_PUBLIC_SYMBOL bool SPIRVToMSLConversionConfiguration::matches(const SPIRVToMSLConversionConfiguration& other) const {
if ( !options.matches(other.options) ) { return false; }
@@ -180,17 +185,20 @@
}
for (const auto& rb : resourceBindings) {
- if (rb.outIsUsedByShader && !containsMatching(other.resourceBindings, rb)) { return false; }
+ if (rb.resourceBinding.stage == options.entryPointStage &&
+ rb.outIsUsedByShader &&
+ !containsMatching(other.resourceBindings, rb)) { return false; }
}
+ for (const auto& db : dynamicBufferDescriptors) {
+ if (db.stage == options.entryPointStage &&
+ !containsMatching(other.dynamicBufferDescriptors, db)) { return false; }
+ }
+
for (uint32_t dsIdx : discreteDescriptorSets) {
if ( !contains(other.discreteDescriptorSets, dsIdx)) { return false; }
}
- for (const auto& db : dynamicBufferDescriptors) {
- if ( !containsMatching(other.dynamicBufferDescriptors, db)) { return false; }
- }
-
return true;
}
@@ -226,7 +234,7 @@
}
}
-MVK_PUBLIC_SYMBOL bool SPIRVToMSLConverter::convert(SPIRVToMSLConversionConfiguration& context,
+MVK_PUBLIC_SYMBOL bool SPIRVToMSLConverter::convert(SPIRVToMSLConversionConfiguration& shaderConfig,
bool shouldLogSPIRV,
bool shouldLogMSL,
bool shouldLogGLSL) {
@@ -250,36 +258,36 @@
#endif
pMSLCompiler = new CompilerMSL(_spirv);
- if (context.options.hasEntryPoint()) {
- pMSLCompiler->set_entry_point(context.options.entryPointName, context.options.entryPointStage);
+ if (shaderConfig.options.hasEntryPoint()) {
+ pMSLCompiler->set_entry_point(shaderConfig.options.entryPointName, shaderConfig.options.entryPointStage);
}
// Set up tessellation parameters if needed.
- if (context.options.entryPointStage == ExecutionModelTessellationControl ||
- context.options.entryPointStage == ExecutionModelTessellationEvaluation) {
- if (context.options.tessPatchKind != ExecutionModeMax) {
- pMSLCompiler->set_execution_mode(context.options.tessPatchKind);
+ if (shaderConfig.options.entryPointStage == ExecutionModelTessellationControl ||
+ shaderConfig.options.entryPointStage == ExecutionModelTessellationEvaluation) {
+ if (shaderConfig.options.tessPatchKind != ExecutionModeMax) {
+ pMSLCompiler->set_execution_mode(shaderConfig.options.tessPatchKind);
}
- if (context.options.numTessControlPoints != 0) {
- pMSLCompiler->set_execution_mode(ExecutionModeOutputVertices, context.options.numTessControlPoints);
+ if (shaderConfig.options.numTessControlPoints != 0) {
+ pMSLCompiler->set_execution_mode(ExecutionModeOutputVertices, shaderConfig.options.numTessControlPoints);
}
}
// Establish the MSL options for the compiler
// This needs to be done in two steps...for CompilerMSL and its superclass.
- pMSLCompiler->set_msl_options(context.options.mslOptions);
+ pMSLCompiler->set_msl_options(shaderConfig.options.mslOptions);
auto scOpts = pMSLCompiler->get_common_options();
- scOpts.vertex.flip_vert_y = context.options.shouldFlipVertexY;
+ scOpts.vertex.flip_vert_y = shaderConfig.options.shouldFlipVertexY;
pMSLCompiler->set_common_options(scOpts);
// Add shader inputs
- for (auto& si : context.shaderInputs) {
+ for (auto& si : shaderConfig.shaderInputs) {
pMSLCompiler->add_msl_shader_input(si.shaderInput);
}
// Add resource bindings and hardcoded constexpr samplers
- for (auto& rb : context.resourceBindings) {
+ for (auto& rb : shaderConfig.resourceBindings) {
auto& rbb = rb.resourceBinding;
pMSLCompiler->add_msl_resource_binding(rbb);
@@ -290,15 +298,15 @@
// Add any descriptor sets that are not using Metal argument buffers.
// This only has an effect if SPIRVToMSLConversionConfiguration::options::mslOptions::argument_buffers is enabled.
- for (uint32_t dsIdx : context.discreteDescriptorSets) {
+ for (uint32_t dsIdx : shaderConfig.discreteDescriptorSets) {
pMSLCompiler->add_discrete_descriptor_set(dsIdx);
}
// Add any dynamic buffer bindings.
// This only has an applies if SPIRVToMSLConversionConfiguration::options::mslOptions::argument_buffers is enabled.
- if (context.options.mslOptions.argument_buffers) {
- for (auto& db : context.dynamicBufferDescriptors) {
- if (db.stage == context.options.entryPointStage) {
+ if (shaderConfig.options.mslOptions.argument_buffers) {
+ for (auto& db : shaderConfig.dynamicBufferDescriptors) {
+ if (db.stage == shaderConfig.options.entryPointStage) {
pMSLCompiler->add_dynamic_buffer(db.descriptorSet, db.binding, db.index);
}
}
@@ -321,7 +329,7 @@
// Populate the shader conversion results with info from the compilation run,
// and mark which vertex attributes and resource bindings are used by the shader
- populateEntryPoint(pMSLCompiler, context.options);
+ populateEntryPoint(pMSLCompiler, shaderConfig.options);
_shaderConversionResults.isRasterizationDisabled = pMSLCompiler && pMSLCompiler->get_is_rasterization_disabled();
_shaderConversionResults.isPositionInvariant = pMSLCompiler && pMSLCompiler->is_position_invariant();
_shaderConversionResults.needsSwizzleBuffer = pMSLCompiler && pMSLCompiler->needs_swizzle_buffer();
@@ -335,19 +343,19 @@
// When using Metal argument buffers, if the shader is provided with dynamic buffer offsets,
// then it needs a buffer to hold these dynamic offsets.
_shaderConversionResults.needsDynamicOffsetBuffer = false;
- if (context.options.mslOptions.argument_buffers) {
- for (auto& db : context.dynamicBufferDescriptors) {
- if (db.stage == context.options.entryPointStage) {
+ if (shaderConfig.options.mslOptions.argument_buffers) {
+ for (auto& db : shaderConfig.dynamicBufferDescriptors) {
+ if (db.stage == shaderConfig.options.entryPointStage) {
_shaderConversionResults.needsDynamicOffsetBuffer = true;
}
}
}
- for (auto& ctxSI : context.shaderInputs) {
+ for (auto& ctxSI : shaderConfig.shaderInputs) {
ctxSI.outIsUsedByShader = pMSLCompiler->is_msl_shader_input_used(ctxSI.shaderInput.location);
}
- for (auto& ctxRB : context.resourceBindings) {
- if (ctxRB.resourceBinding.stage == context.options.entryPointStage) {
+ for (auto& ctxRB : shaderConfig.resourceBindings) {
+ if (ctxRB.resourceBinding.stage == shaderConfig.options.entryPointStage) {
ctxRB.outIsUsedByShader = pMSLCompiler->is_msl_resource_binding_used(ctxRB.resourceBinding.stage,
ctxRB.resourceBinding.desc_set,
ctxRB.resourceBinding.binding);
diff --git a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h
index ec53122..688acd0 100644
--- a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h
+++ b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h
@@ -171,15 +171,15 @@
void markAllInputsAndResourcesUsed();
/**
- * Returns whether this configuration matches the other context. It does if the
- * respective options match and any vertex attributes and resource bindings used
+ * Returns whether this configuration matches the other configuration. It does if
+ * the respective options match and any vertex attributes and resource bindings used
* by this configuration can be found in the other configuration. Vertex attributes
* and resource bindings that are in the other configuration but are not used by
* the shader that created this configuration, are ignored.
*/
bool matches(const SPIRVToMSLConversionConfiguration& other) const;
- /** Aligns certain aspects of this configuration with the source context. */
+ /** Aligns certain aspects of this configuration with the source configuration. */
void alignWith(const SPIRVToMSLConversionConfiguration& srcContext);
} SPIRVToMSLConversionConfiguration;
@@ -274,7 +274,7 @@
* and optionally, the original GLSL (as converted from the SPIR_V), should be logged
* to the result log of this converter. This can be useful during shader debugging.
*/
- bool convert(SPIRVToMSLConversionConfiguration& context,
+ bool convert(SPIRVToMSLConversionConfiguration& shaderConfig,
bool shouldLogSPIRV = false,
bool shouldLogMSL = false,
bool shouldLogGLSL = false);
