From f0cd62b37c5dfbbdb3fb205f1be2b8beba0dfed4 Mon Sep 17 00:00:00 2001 From: lucy96chen <47800040+lucy96chen@users.noreply.github.com> Date: Wed, 12 Oct 2022 09:55:09 -0700 Subject: Shader caching (#2432) * Changed all getEntryPointCode calls to use RendererBase::getEntryPointCodeFromShaderCache * Hashing hooked up, tests pass but need to add more to fully test functionality * checkpoint * Checkpoint: File system creation seems functional, saving is broken * checkpoint: Fixed filename generation from MD5 hash, shader blob might be going missing ahead of pipeline state creation * Fixed a lot of bugs related to hash code generation, shader cache is likely working but needs further testing * Added workaround for module loading by re-creating the test device, shader cache test functional * Vulkan shader caching bug fixed, checkpoint commit before more refinement * pre-ToT merge checkpoint * checkpoint commit, improving cache keys * Significantly expanded items included in the dependency hash for Module; Added dependency hash functions to SpecializedComponentType and RenamedEntryPointComponentType * Temporarily disable shader cache test * Mid cleanup changes, solution successfully builds * Added several helper update functions to slang-md5 to help simplify usage; Added a function under ISession to compute a hash for all linkage-related items; Function renames and cleaned up some comments * Ran premake.bat; Renamed getASTBasedHashCode to computeASTBasedHash * Added slang unit tests for Checksum and MD5; Extended gfx shader cache test to test with multiple shader files and one shader file with multiple entry points * Solution builds and shader cache tests pass, but at least a couple other tests now failing * ran premake.bat * More cleanup changes * Added shaderCachePath field to IDevice desc in gfx.slang, gfx-smoke.slang should be functional * ran premake * cleanup changes; Adding test printf to getEntryPointCodeFromShaderCache to see if output can be seen in CI * Removed debugging printfs; Added handling for getEntryPointCode() failing * Cleanup changes; Jonathan's fixes to SerialWriter to zero initialize otherwise uninitialized memory; Change to SwizzleExpr creation to zero initialize elementCount * Changed enable_if_t to enable_if * Fixed enable_if * Added test for import vs include and changes to included and imported files; Fixed build errors in CUDA; Renamed shader cache statistics fields * cleanup changes * Readd removed file * Restructured computeDependencyBasedHash calls, added computeDependencyBasedHashImpl to all classes dervied from ComponentType * Applied same restructuring to the AST hash functions * Cleanup changes; Moved HashBuilder out to slang-digest.h and added some helper functions to streamline the process of adding items to a hash * Cleanup; Fixed incorrect expected results for shader import and include test --- source/slang/slang-ast-builder.h | 15 ++- source/slang/slang-check-expr.cpp | 4 + source/slang/slang-compiler.cpp | 24 +++++ source/slang/slang-compiler.h | 119 ++++++++++++++++++++- source/slang/slang-hash-utils.h | 55 ++++++++++ source/slang/slang-serialize-ast.cpp | 25 +++++ source/slang/slang-serialize-ast.h | 2 + source/slang/slang-serialize-type-info.h | 12 +++ source/slang/slang-serialize.cpp | 17 ++- source/slang/slang-serialize.h | 25 ++++- source/slang/slang.cpp | 175 ++++++++++++++++++++++++++++++- 11 files changed, 460 insertions(+), 13 deletions(-) create mode 100644 source/slang/slang-hash-utils.h (limited to 'source/slang') diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h index 3023e274d..91fe63c88 100644 --- a/source/slang/slang-ast-builder.h +++ b/source/slang/slang-ast-builder.h @@ -155,9 +155,20 @@ public: /// Create AST types template - T* create() { return _initAndAdd(new (m_arena.allocate(sizeof(T))) T); } + T* create() + { + auto alloced = m_arena.allocate(sizeof(T)); + memset(alloced, 0, sizeof(T)); + return _initAndAdd(new (alloced) T); + } + template - T* create(TArgs... args) { return _initAndAdd(new (m_arena.allocate(sizeof(T))) T(args...)); } + T* create(TArgs... args) + { + auto alloced = m_arena.allocate(sizeof(T)); + memset(alloced, 0, sizeof(T)); + return _initAndAdd(new (alloced) T(args...)); + } template SLANG_FORCE_INLINE T* getOrCreate(TArgs ... args) diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index 2987fecee..f1ccddf15 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -2195,6 +2195,10 @@ namespace Slang SwizzleExpr* swizExpr = m_astBuilder->create(); swizExpr->loc = memberRefExpr->loc; swizExpr->base = memberRefExpr->baseExpression; + swizExpr->elementIndices[0] = 0; + swizExpr->elementIndices[1] = 0; + swizExpr->elementIndices[2] = 0; + swizExpr->elementIndices[3] = 0; swizExpr->memberOpLoc = memberRefExpr->memberOperatorLoc; IntegerLiteralValue limitElement = baseElementCount; diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index 06cc9d759..889ecc58a 100644 --- a/source/slang/slang-compiler.cpp +++ b/source/slang/slang-compiler.cpp @@ -35,6 +35,7 @@ #include "slang-glsl-extension-tracker.h" #include "slang-emit-cuda.h" +#include "slang-serialize-ast.h" #include "slang-serialize-container.h" namespace Slang @@ -222,6 +223,16 @@ namespace Slang visitor->visitEntryPoint(this, as(specializationInfo)); } + void EntryPoint::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt entryPointIndex) + { + // CompositeComponentType will have already hashed the relevant entry point's name + // and file path dependencies, so we immediately return. + SLANG_UNUSED(builder); + SLANG_UNUSED(entryPointIndex); + } + List const& EntryPoint::getModuleDependencies() { if(auto module = getModule()) @@ -290,6 +301,19 @@ namespace Slang return Super::getInterface(guid); } + void TypeConformance::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt entryPointIndex) + { + SLANG_UNUSED(entryPointIndex); + + //TODO: Implement some kind of hashInto for Val then replace this + auto subtypeWitness = m_subtypeWitness->toString(); + + builder.addToDigest(subtypeWitness); + builder.addToDigest(m_conformanceIdOverride); + } + List const& TypeConformance::getModuleDependencies() { return m_moduleDependency.getModuleList(); diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index 46be07fa3..016c8fefa 100755 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -3,6 +3,7 @@ #include "../core/slang-basic.h" #include "../core/slang-shared-library.h" +#include "../core/slang-digest.h" #include "../compiler-core/slang-downstream-compiler.h" #include "../compiler-core/slang-downstream-compiler-util.h" @@ -282,14 +283,23 @@ namespace Slang const char* newName, slang::IComponentType** outEntryPoint) SLANG_OVERRIDE; SLANG_NO_THROW SlangResult SLANG_MCALL link( - slang::IComponentType** outLinkedComponentType, - ISlangBlob** outDiagnostics) SLANG_OVERRIDE; + slang::IComponentType** outLinkedComponentType, + ISlangBlob** outDiagnostics) SLANG_OVERRIDE; SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable( int entryPointIndex, int targetIndex, ISlangSharedLibrary** outSharedLibrary, slang::IBlob** outDiagnostics) SLANG_OVERRIDE; + /// ComponentType is the only class inheriting from IComponentType that provides a + /// meaningful implementation for these two functions. All others should forward these + /// and implement updateDependencyBasedHash and updateASTBasedHash instead. + SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash( + SlangInt entryPointIndex, + SlangInt targetIndex, + slang::Digest* outHash) SLANG_OVERRIDE; + SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash) SLANG_OVERRIDE; + /// Get the linkage (aka "session" in the public API) for this component type. Linkage* getLinkage() { return m_linkage; } @@ -298,6 +308,16 @@ namespace Slang /// The `target` must be a target on the `Linkage` that was used to create this program. TargetProgram* getTargetProgram(TargetRequest* target); + /// Update the hash builder with the dependencies for this component type. + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) = 0; + + /// Update the hash builder with the AST contents for this component type. + /// The AST is associated with a Module component, so most derived ComponentType classes + /// will simply do nothing with this. + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) = 0; + /// Get the number of entry points linked into this component type. virtual Index getEntryPointCount() = 0; @@ -495,6 +515,12 @@ namespace Slang Linkage* linkage, List> const& childComponents); + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) override; + + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override; + List> const& getChildComponents() { return m_childComponents; }; Index getChildComponentCount() { return m_childComponents.getCount(); } RefPtr getChildComponent(Index index) { return m_childComponents[index]; } @@ -571,6 +597,15 @@ namespace Slang List const& specializationArgs, DiagnosticSink* sink); + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) override; + + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override + { + SLANG_UNUSED(hashBuilder); + } + /// Get the base (unspecialized) component type that is being specialized. RefPtr getBaseComponentType() { return m_base; } @@ -754,6 +789,16 @@ namespace Slang void acceptVisitor(ComponentTypeVisitor* visitor, SpecializationInfo* specializationInfo) SLANG_OVERRIDE; + + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) override; + + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override + { + SLANG_UNUSED(hashBuilder); + } + private: RefPtr m_base; String m_entryPointNameOverride; @@ -846,6 +891,28 @@ namespace Slang return Super::getEntryPointHostCallable(entryPointIndex, targetIndex, outSharedLibrary, outDiagnostics); } + SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash( + SlangInt entryPointIndex, + SlangInt targetIndex, + slang::Digest* outHash) SLANG_OVERRIDE + { + return Super::computeDependencyBasedHash(entryPointIndex, targetIndex, outHash); + } + + SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash) + { + return Super::computeASTBasedHash(outHash); + } + + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) override; + + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override + { + SLANG_UNUSED(hashBuilder); + } + /// Create an entry point that refers to the given function. static RefPtr create( Linkage* linkage, @@ -1051,6 +1118,28 @@ namespace Slang entryPointIndex, targetIndex, outSharedLibrary, outDiagnostics); } + SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash( + SlangInt entryPointIndex, + SlangInt targetIndex, + slang::Digest* outHash) SLANG_OVERRIDE + { + return Super::computeDependencyBasedHash(entryPointIndex, targetIndex, outHash); + } + + SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash) + { + return Super::computeASTBasedHash(outHash); + } + + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) override; + + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override + { + SLANG_UNUSED(hashBuilder); + } + List const& getModuleDependencies() SLANG_OVERRIDE; List const& getFilePathDependencies() SLANG_OVERRIDE; @@ -1225,6 +1314,25 @@ namespace Slang // + SLANG_NO_THROW void SLANG_MCALL computeDependencyBasedHash( + SlangInt entryPointIndex, + SlangInt targetIndex, + slang::Digest* outHash) SLANG_OVERRIDE + { + return Super::computeDependencyBasedHash(entryPointIndex, targetIndex, outHash); + } + + SLANG_NO_THROW void SLANG_MCALL computeASTBasedHash(slang::Digest* outHash) + { + return Super::computeASTBasedHash(outHash); + } + + virtual void updateDependencyBasedHash( + DigestBuilder& hashBuilder, + SlangInt entryPointIndex) override; + + virtual void updateASTBasedHash(DigestBuilder& hashBuilder) override; + /// Create a module (initially empty). Module(Linkage* linkage, ASTBuilder* astBuilder = nullptr); @@ -1657,6 +1765,13 @@ namespace Slang SLANG_NO_THROW SlangResult SLANG_MCALL createCompileRequest( SlangCompileRequest** outCompileRequest) override; + // Updates the supplied has builder with linkage-related information, which includes preprocessor + // defines, the compiler version, and other compiler options. This is then merged with the hash + // produced for the program to produce a key that can be used with the shader cache. + void updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt targetIndex); + void addTarget( slang::TargetDesc const& desc); SlangResult addSearchPath( diff --git a/source/slang/slang-hash-utils.h b/source/slang/slang-hash-utils.h new file mode 100644 index 000000000..d0d610cb8 --- /dev/null +++ b/source/slang/slang-hash-utils.h @@ -0,0 +1,55 @@ +// slang-hash-utils.h - Utility functions specifically designed to be used with slang::Digest +#pragma once +#include "../../slang.h" +#include "../core/slang-basic.h" +#include "../core/slang-md5.h" +#include "../core/slang-digest.h" + +namespace Slang +{ + // Compute the hash for an UnownedStringSlice + inline slang::Digest computeHashForStringSlice(UnownedStringSlice text) + { + DigestBuilder builder; + builder.addToDigest(text); + + slang::Digest textHash; + builder.finalize(&textHash); + + return textHash; + } + + // Combines the two provided hashes. + inline slang::Digest combineHashes(const slang::Digest& hashA, const slang::Digest& hashB) + { + DigestBuilder builder; + builder.addToDigest(hashA); + builder.addToDigest(hashB); + + slang::Digest combined; + builder.finalize(&combined); + return combined; + } + + // Returns the stored hash in checksum as a String. + inline StringBuilder hashToString(const slang::Digest& hash) + { + StringBuilder filename; + + for (Index i = 0; i < 4; ++i) + { + auto hashSegmentString = String(hash.values[i], 16); + + auto leadingZeroCount = 8 - hashSegmentString.getLength(); + for (Index j = 0; j < leadingZeroCount; ++j) + { + filename.append("0"); + } + filename.append(hashSegmentString.getBuffer()); + } + + return filename; + } + + // TODO: fromString implementation? +} diff --git a/source/slang/slang-serialize-ast.cpp b/source/slang/slang-serialize-ast.cpp index 31a3f6ac0..04b5f71b1 100644 --- a/source/slang/slang-serialize-ast.cpp +++ b/source/slang/slang-serialize-ast.cpp @@ -154,4 +154,29 @@ struct ASTFieldAccess return SLANG_OK; } +/* static */List ASTSerialUtil::serializeAST(ModuleDecl* moduleDecl) +{ + //TODO: we should store `classes` in GlobalSession to avoid recomputing them every time. + RefPtr classes; + SerialClassesUtil::create(classes); + + List contents; + OwnedMemoryStream stream(FileAccess::ReadWrite); + + // Only serialize out things *in* this module + ModuleSerialFilter filterStorage(moduleDecl); + + SerialFilter* filter = moduleDecl ? &filterStorage : nullptr; + + SerialWriter writer(classes, filter); + + // Lets serialize it all + writer.addPointer(moduleDecl); + // Let's stick it all in a stream + writer.write(&stream); + + stream.swapContents(contents); + return contents; +} + } // namespace Slang diff --git a/source/slang/slang-serialize-ast.h b/source/slang/slang-serialize-ast.h index 3aa790c86..1052c9a0a 100644 --- a/source/slang/slang-serialize-ast.h +++ b/source/slang/slang-serialize-ast.h @@ -48,6 +48,8 @@ struct ASTSerialUtil /// Tries to serialize out, read back in and test the results are the same. /// Will write dumped out node to files static SlangResult testSerialize(NodeBase* node, RootNamePool* rootNamePool, SharedASTBuilder* sharedASTBuilder, SourceManager* sourceManager); + + static List serializeAST(ModuleDecl* moduleDecl); }; } // namespace Slang diff --git a/source/slang/slang-serialize-type-info.h b/source/slang/slang-serialize-type-info.h index c80eb8051..6258a129d 100644 --- a/source/slang/slang-serialize-type-info.h +++ b/source/slang/slang-serialize-type-info.h @@ -104,6 +104,12 @@ struct SerialTypeInfo static void toSerial(SerialWriter* writer, const void* inNative, void* outSerial) { SerialElementType* serial = (SerialElementType*)outSerial; + + if (writer->getFlags() & SerialWriter::Flag::ZeroInitialize) + { + ::memset(outSerial, 0, sizeof(SerialElementType) * N); + } + const T* native = (const T*)inNative; for (Index i = 0; i < Index(N); ++i) { @@ -278,6 +284,12 @@ struct SerialTypeInfo> keys.setCount(count); values.setCount(count); + if (writer->getFlags() & SerialWriter::Flag::ZeroInitialize) + { + ::memset(keys.getBuffer(), 0, count * sizeof(KeySerialType)); + ::memset(values.getBuffer(), 0, count * sizeof(ValueSerialType)); + } + Index i = 0; for (const auto& pair : src) { diff --git a/source/slang/slang-serialize.cpp b/source/slang/slang-serialize.cpp index 71ef303b7..9b63d47c5 100644 --- a/source/slang/slang-serialize.cpp +++ b/source/slang/slang-serialize.cpp @@ -210,10 +210,11 @@ SerialClasses::SerialClasses(): // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SerialWriter !!!!!!!!!!!!!!!!!!!!!!!!!!!! -SerialWriter::SerialWriter(SerialClasses* classes, SerialFilter* filter) : - m_arena(2048), - m_classes(classes), - m_filter(filter) +SerialWriter::SerialWriter(SerialClasses* classes, SerialFilter* filter, Flags flags) + : m_arena(2048) + , m_classes(classes) + , m_filter(filter) + , m_flags(flags) { // 0 is always the null pointer m_entries.add(nullptr); @@ -236,6 +237,7 @@ SerialIndex SerialWriter::writeObject(const SerialClass* serialCls, const void* nodeEntry->typeKind = serialCls->typeKind; nodeEntry->subType = serialCls->subType; + nodeEntry->_pad0 = 0; nodeEntry->info = SerialInfo::makeEntryInfo(serialCls->alignment); @@ -244,6 +246,12 @@ SerialIndex SerialWriter::writeObject(const SerialClass* serialCls, const void* // Point to start of payload uint8_t* serialPayload = (uint8_t*)(nodeEntry + 1); + + if (m_flags & Flag::ZeroInitialize) + { + ::memset(serialPayload, 0, serialCls->size); + } + while (serialCls) { for (Index i = 0; i < serialCls->fieldsCount; ++i) @@ -483,6 +491,7 @@ SlangResult SerialWriter::write(Stream* stream) for (Index i = 1; i < entriesCount; ++i) { SerialInfo::Entry* next = entries[i + 1]; + // Before writing we need to store the next alignment const size_t nextAlignment = SerialInfo::getAlignment(next->info); diff --git a/source/slang/slang-serialize.h b/source/slang/slang-serialize.h index fcd2daa1f..e08d26dd5 100644 --- a/source/slang/slang-serialize.h +++ b/source/slang/slang-serialize.h @@ -316,6 +316,18 @@ void SerialReader::getArray(SerialIndex index, List& out) class SerialWriter : public RefObject { public: + typedef uint32_t Flags; + struct Flag + { + enum Enum : Flags + { + /// If set will zero initialize backing memory. This is slower but + /// is desirable to make two serializations of the same thing produce the + /// identical serialized result. + ZeroInitialize = 0x1 + }; + }; + SerialIndex addPointer(const NodeBase* ptr); SerialIndex addPointer(const RefObject* ptr); @@ -367,8 +379,11 @@ public: /// Used for attaching extra objects necessary for serializing SerialExtraObjects& getExtraObjects() { return m_extraObjects; } + /// Get the flag + Flags getFlags() const { return m_flags; } + /// Ctor - SerialWriter(SerialClasses* classes, SerialFilter* filter); + SerialWriter(SerialClasses* classes, SerialFilter* filter, Flags flags = Flag::ZeroInitialize); protected: @@ -388,7 +403,6 @@ protected: Dictionary m_ptrMap; // Maps a pointer to an entry index - // NOTE! Assumes the content stays in scope! SliceMap m_sliceMap; SliceMap m_importSymbolMap; @@ -399,6 +413,8 @@ protected: MemoryArena m_arena; ///< Holds the payloads SerialClasses* m_classes; SerialFilter* m_filter; ///< Filter to control what is serialized + + Flags m_flags; ///< Flags to control behavior }; // --------------------------------------------------------------------------- @@ -419,6 +435,11 @@ SerialIndex SerialWriter::addArray(const T* in, Index count) List work; work.setCount(count); + if (getFlags() & Flag::ZeroInitialize) + { + ::memset(work.getBuffer(), 0, sizeof(ElementSerialType) * count); + } + for (Index i = 0; i < count; ++i) { ElementTypeInfo::toSerial(this, &in[i], &work[i]); diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index a3fd91ce0..a6dcf8ab2 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -44,6 +44,9 @@ #include "slang-check-impl.h" +#include "../core/slang-md5.h" +#include "slang-hash-utils.h" + #include "../../slang-tag-version.h" // Used to print exception type names in internal-compiler-error messages @@ -1318,6 +1321,54 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Linkage::createCompileRequest( return SLANG_OK; } +void Linkage::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt targetIndex) +{ + // Add the Slang compiler version to the hash + auto version = String(getBuildTagString()); + builder.addToDigest(version); + + // Add the search directory paths to the hash + auto searchDirectoryList = getSearchDirectories().searchDirectories; + for (auto& searchDir : searchDirectoryList) + { + auto searchPath = searchDir.path; + builder.addToDigest(searchPath); + } + + // Add the preprocessor definitions to the hash + for (auto& key : preprocessorDefinitions) + { + builder.addToDigest(key.Key); + builder.addToDigest(key.Value); + } + + // Add the target specified by targetIndex + auto targetReq = targets[targetIndex]; + builder.addToDigest(targetReq->getTarget()); + builder.addToDigest(targetReq->getTargetFlags()); + builder.addToDigest(targetReq->getFloatingPointMode()); + builder.addToDigest(targetReq->getLineDirectiveMode()); + builder.addToDigest(targetReq->shouldDumpIntermediates()); + builder.addToDigest(targetReq->getForceGLSLScalarBufferLayout()); + builder.addToDigest(targetReq->shouldTrackLiveness()); + + auto targetProfile = targetReq->getTargetProfile(); + builder.addToDigest(targetProfile.getStage()); + builder.addToDigest(targetProfile.getVersion()); + builder.addToDigest(targetProfile.getFamily()); + + auto targetProfileName = String(targetProfile.getName()); + builder.addToDigest(targetProfileName); + + auto cookedCapabilities = targetReq->getTargetCaps().getExpandedAtoms(); + for (auto& capability : cookedCapabilities) + { + builder.addToDigest(capability); + } +} + SlangResult Linkage::addSearchPath( char const* path) { @@ -1618,10 +1669,20 @@ void TranslationUnitRequest::_addSourceFile(SourceFile* sourceFile) // an associated path and/or wasn't from a file. auto pathInfo = sourceFile->getPathInfo(); - if (pathInfo.hasFileFoundPath()) + if (pathInfo.hasFoundPath()) { getModule()->addFilePathDependency(pathInfo.foundPath); } + else + { + // No path exists for this source, so we generate a new string to use as a + // fake path in the list of file path dependencies. This is needed to account + // for non-file-based dependencies later when shader files are being hashed for + // the shader cache. + + slang::Digest sourceHash = computeHashForStringSlice(sourceFile->getContent()); + getModule()->addFilePathDependency(hashToString(sourceHash)); + } } List const& TranslationUnitRequest::getSourceFiles() @@ -3149,8 +3210,6 @@ void FilePathDependencyList::addDependency(Module* module) } } - - // // Module // @@ -3178,6 +3237,22 @@ ISlangUnknown* Module::getInterface(const Guid& guid) return Super::getInterface(guid); } +void Module::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt entryPointIndex) +{ + // CompositeComponentType will have already hashed this Module's file + // dependencies. + SLANG_UNUSED(builder); + SLANG_UNUSED(entryPointIndex); +} + +void Module::updateASTBasedHash(DigestBuilder& builder) +{ + auto serializedAST = ASTSerialUtil::serializeAST(getModuleDecl()); + builder.addToDigest(serializedAST); +} + void Module::addModuleDependency(Module* module) { m_moduleDependencyList.addDependency(module); @@ -3376,6 +3451,52 @@ SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::getEntryPointCode( return artifact->loadBlob(ArtifactKeep::Yes, outCode); } +SLANG_NO_THROW void SLANG_MCALL ComponentType::computeDependencyBasedHash( + SlangInt entryPointIndex, + SlangInt targetIndex, + slang::Digest* outHash) +{ + DigestBuilder builder; + + // A note on enums that may be hashed in as part of the following two function calls: + // + // While enums are not guaranteed to be encoded the same way across all versions of + // the compiler, part of hashing the linkage is hashing in the compiler version. + // Consequently, any encoding differences as a result of different compiler versions + // will already be reflected in the resulting hash. + getLinkage()->updateDependencyBasedHash(builder, targetIndex); + updateDependencyBasedHash(builder, entryPointIndex); + + // Add file path dependencies to the hash - all child components + // will have file path dependencies that are a subset of this list. + auto fileDeps = getFilePathDependencies(); + for (auto& file : fileDeps) + { + builder.addToDigest(file); + } + + // Add the name and name override for the specified entry point + // to the hash. + auto entryPointName = getEntryPoint(entryPointIndex)->getName()->text; + builder.addToDigest(entryPointName); + auto entryPointNameOverride = getEntryPointNameOverride(entryPointIndex); + builder.addToDigest(entryPointNameOverride); + + slang::Digest hash; + builder.finalize(&hash); + *outHash = hash; +} + +SLANG_NO_THROW void SLANG_MCALL ComponentType::computeASTBasedHash(slang::Digest* outHash) +{ + DigestBuilder builder; + updateASTBasedHash(builder); + + slang::Digest hash; + builder.finalize(&hash); + *outHash = hash; +} + SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::getEntryPointHostCallable( int entryPointIndex, int targetIndex, @@ -3708,6 +3829,28 @@ CompositeComponentType::CompositeComponentType( } } +void CompositeComponentType::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt entryPointIndex) +{ + auto componentCount = getChildComponentCount(); + + for (Index i = 0; i < componentCount; ++i) + { + getChildComponent(i)->updateDependencyBasedHash(builder, entryPointIndex); + } +} + +void CompositeComponentType::updateASTBasedHash(DigestBuilder& builder) +{ + auto componentCount = getChildComponentCount(); + + for (Index i = 0; i < componentCount; ++i) + { + getChildComponent(i)->updateASTBasedHash(builder); + } +} + Index CompositeComponentType::getEntryPointCount() { return m_entryPoints.getCount(); @@ -4187,6 +4330,22 @@ SpecializedComponentType::SpecializedComponentType( collector.visitSpecialized(this); } +void SpecializedComponentType::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt entryPointIndex) +{ + auto specializationArgCount = getSpecializationArgCount(); + for (Index i = 0; i < specializationArgCount; ++i) + { + auto specializationArg = getSpecializationArg(i); + auto argString = specializationArg.val->toString(); + builder.addToDigest(argString); + } + + slang::Digest baseHash; + getBaseComponentType()->updateDependencyBasedHash(builder, entryPointIndex); +} + void SpecializedComponentType::acceptVisitor(ComponentTypeVisitor* visitor, SpecializationInfo* specializationInfo) { SLANG_ASSERT(specializationInfo == nullptr); @@ -4231,6 +4390,16 @@ void RenamedEntryPointComponentType::acceptVisitor( this, as(specializationInfo)); } +void RenamedEntryPointComponentType::updateDependencyBasedHash( + DigestBuilder& builder, + SlangInt entryPointIndex) +{ + // CompositeComponentType will have already hashed the name override and file + // dependencies for this entry point. + SLANG_UNUSED(entryPointIndex); + SLANG_UNUSED(builder); +} + void ComponentTypeVisitor::visitChildren(CompositeComponentType* composite, CompositeComponentType::CompositeSpecializationInfo* specializationInfo) { auto childCount = composite->getChildComponentCount(); -- cgit v1.2.3