From d349fd9e1f65fd32b2f4ea0e38c5084256d0dd04 Mon Sep 17 00:00:00 2001 From: kaizhangNV <149626564+kaizhangNV@users.noreply.github.com> Date: Thu, 20 Jun 2024 20:59:33 -0700 Subject: Add capture logic to other interfaces. (#4412) * Add capture logic to other interfaces. Add capture logics to ISession, IModule, ITypeConformance, IEntryPoint ICompositeComponentType. Add few encode methods to encode the array. Fix some capture logic in global session. We will not need to encode the null_ptr output before actual actual of the captured APIs. Previously we used this as a place holder, but it's actually not necessary, it can be detected if the output is not captured during replay. * capture/replay: dump the shader files to disk Dump the shader files to disk. Also set a default directory for the capture files. --- source/slang-capture-replay/slang-module.cpp | 239 ++++++++++++++++++++++++++- 1 file changed, 236 insertions(+), 3 deletions(-) (limited to 'source/slang-capture-replay/slang-module.cpp') diff --git a/source/slang-capture-replay/slang-module.cpp b/source/slang-capture-replay/slang-module.cpp index 55743dd78..0b5ed47f1 100644 --- a/source/slang-capture-replay/slang-module.cpp +++ b/source/slang-capture-replay/slang-module.cpp @@ -3,10 +3,14 @@ namespace SlangCapture { - ModuleCapture::ModuleCapture(slang::IModule* module) - : m_actualModule(module) + ModuleCapture::ModuleCapture(slang::IModule* module, CaptureManager* captureManager) + : m_actualModule(module), + m_captureManager(captureManager) { SLANG_CAPTURE_ASSERT(m_actualModule != nullptr); + SLANG_CAPTURE_ASSERT(m_captureManager != nullptr); + + m_moduleHandle = reinterpret_cast(m_actualModule.get()); slangCaptureLog(LogLevel::Verbose, "%s: %p\n", __PRETTY_FUNCTION__, module); } @@ -29,8 +33,20 @@ namespace SlangCapture { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_findEntryPointByName, m_moduleHandle); + encoder->encodeString(name); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->findEntryPointByName(name, outEntryPoint); + { + encoder->encodeAddress(*outEntryPoint); + m_captureManager->endMethodCaptureAppendOutput(); + } + if (SLANG_OK == res) { EntryPointCapture* entryPointCapture = getEntryPointCapture(*outEntryPoint); @@ -41,6 +57,7 @@ namespace SlangCapture SLANG_NO_THROW SlangInt32 ModuleCapture::getDefinedEntryPointCount() { + // No need to capture this call as it is just a query. slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); SlangInt32 res = m_actualModule->getDefinedEntryPointCount(); return res; @@ -51,8 +68,21 @@ namespace SlangCapture // This call is to find the existing entry point, so it has been created already. Therefore, we don't create a new one // and assert the error if it is not found in our map. slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getDefinedEntryPoint, m_moduleHandle); + encoder->encodeInt32(index); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->getDefinedEntryPoint(index, outEntryPoint); + { + encoder->encodeAddress(*outEntryPoint); + m_captureManager->endMethodCaptureAppendOutput(); + } + if (*outEntryPoint) { EntryPointCapture* entryPointCapture = m_mapEntryPointToCapture.tryGetValue(*outEntryPoint); @@ -71,19 +101,41 @@ namespace SlangCapture SLANG_NO_THROW SlangResult ModuleCapture::serialize(ISlangBlob** outSerializedBlob) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_serialize, m_moduleHandle); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->serialize(outSerializedBlob); + + { + encoder->encodeAddress(*outSerializedBlob); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } SLANG_NO_THROW SlangResult ModuleCapture::writeToFile(char const* fileName) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_writeToFile, m_moduleHandle); + encoder->encodeString(fileName); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->writeToFile(fileName); return res; } SLANG_NO_THROW const char* ModuleCapture::getName() { + // No need to capture this call as it is just a query. slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); const char* res = m_actualModule->getName(); return res; @@ -91,6 +143,7 @@ namespace SlangCapture SLANG_NO_THROW const char* ModuleCapture::getFilePath() { + // No need to capture this call as it is just a query. slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); const char* res = m_actualModule->getFilePath(); return res; @@ -98,6 +151,7 @@ namespace SlangCapture SLANG_NO_THROW const char* ModuleCapture::getUniqueIdentity() { + // No need to capture this call as it is just a query. slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); const char* res = m_actualModule->getUniqueIdentity(); return res; @@ -111,8 +165,22 @@ namespace SlangCapture { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_findAndCheckEntryPoint, m_moduleHandle); + encoder->encodeString(name); + encoder->encodeEnumValue(stage); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->findAndCheckEntryPoint(name, stage, outEntryPoint, outDiagnostics); + { + encoder->encodeAddress(*outEntryPoint); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + if (SLANG_OK == res) { EntryPointCapture* entryPointCapture = getEntryPointCapture(*outEntryPoint); @@ -124,7 +192,20 @@ namespace SlangCapture SLANG_NO_THROW slang::ISession* ModuleCapture::getSession() { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getSession, m_moduleHandle); + encoder = m_captureManager->endMethodCapture(); + } + slang::ISession* session = m_actualModule->getSession(); + + { + encoder->encodeAddress(session); + m_captureManager->endMethodCaptureAppendOutput(); + } + return session; } @@ -133,12 +214,28 @@ namespace SlangCapture slang::IBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getLayout, m_moduleHandle); + encoder->encodeInt64(targetIndex); + encoder = m_captureManager->endMethodCapture(); + } + slang::ProgramLayout* programLayout = m_actualModule->getLayout(targetIndex, outDiagnostics); + + { + encoder->encodeAddress(*outDiagnostics); + encoder->encodeAddress(programLayout); + m_captureManager->endMethodCaptureAppendOutput(); + } + return programLayout; } SLANG_NO_THROW SlangInt ModuleCapture::getSpecializationParamCount() { + // No need to capture this call as it is just a query. slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); SlangInt res = m_actualModule->getSpecializationParamCount(); return res; @@ -151,7 +248,23 @@ namespace SlangCapture slang::IBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getEntryPointCode, m_moduleHandle); + encoder->encodeInt64(entryPointIndex); + encoder->encodeInt64(targetIndex); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->getEntryPointCode(entryPointIndex, targetIndex, outCode, outDiagnostics); + + { + encoder->encodeAddress(*outCode); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -161,7 +274,22 @@ namespace SlangCapture slang::IBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getTargetCode, m_moduleHandle); + encoder->encodeInt64(targetIndex); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->getTargetCode(targetIndex, outCode, outDiagnostics); + + { + encoder->encodeAddress(*outCode); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -171,7 +299,22 @@ namespace SlangCapture ISlangMutableFileSystem** outFileSystem) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getResultAsFileSystem, m_moduleHandle); + encoder->encodeInt64(entryPointIndex); + encoder->encodeInt64(targetIndex); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->getResultAsFileSystem(entryPointIndex, targetIndex, outFileSystem); + + { + encoder->encodeAddress(*outFileSystem); + } + + // TODO: We might need to wrap the file system object. return res; } @@ -181,7 +324,21 @@ namespace SlangCapture slang::IBlob** outHash) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getEntryPointHash, m_moduleHandle); + encoder->encodeInt64(entryPointIndex); + encoder->encodeInt64(targetIndex); + encoder = m_captureManager->endMethodCapture(); + } + m_actualModule->getEntryPointHash(entryPointIndex, targetIndex, outHash); + + { + encoder->encodeAddress(*outHash); + m_captureManager->endMethodCaptureAppendOutput(); + } } SLANG_NO_THROW SlangResult ModuleCapture::specialize( @@ -191,7 +348,23 @@ namespace SlangCapture ISlangBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_specialize, m_moduleHandle); + encoder->encodeInt64(specializationArgCount); + encoder->encodeStructArray(specializationArgs, specializationArgCount); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->specialize(specializationArgs, specializationArgCount, outSpecializedComponentType, outDiagnostics); + + { + encoder->encodeAddress(*outSpecializedComponentType); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -200,7 +373,21 @@ namespace SlangCapture ISlangBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_link, m_moduleHandle); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->link(outLinkedComponentType, outDiagnostics); + + { + encoder->encodeAddress(*outLinkedComponentType); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -211,7 +398,23 @@ namespace SlangCapture slang::IBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_getEntryPointHostCallable, m_moduleHandle); + encoder->encodeInt32(entryPointIndex); + encoder->encodeInt32(targetIndex); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->getEntryPointHostCallable(entryPointIndex, targetIndex, outSharedLibrary, outDiagnostics); + + { + encoder->encodeAddress(*outSharedLibrary); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -219,7 +422,21 @@ namespace SlangCapture const char* newName, IComponentType** outEntryPoint) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_renameEntryPoint, m_moduleHandle); + encoder->encodeString(newName); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->renameEntryPoint(newName, outEntryPoint); + + { + encoder->encodeAddress(*outEntryPoint); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -230,7 +447,23 @@ namespace SlangCapture ISlangBlob** outDiagnostics) { slangCaptureLog(LogLevel::Verbose, "%s\n", __PRETTY_FUNCTION__); + + ParameterEncoder* encoder {}; + { + encoder = m_captureManager->beginMethodCapture(ApiCallId::IModule_linkWithOptions, m_moduleHandle); + encoder->encodeUint32(compilerOptionEntryCount); + encoder->encodeStructArray(compilerOptionEntries, compilerOptionEntryCount); + encoder = m_captureManager->endMethodCapture(); + } + SlangResult res = m_actualModule->linkWithOptions(outLinkedComponentType, compilerOptionEntryCount, compilerOptionEntries, outDiagnostics); + + { + encoder->encodeAddress(*outLinkedComponentType); + encoder->encodeAddress(*outDiagnostics); + m_captureManager->endMethodCaptureAppendOutput(); + } + return res; } @@ -240,7 +473,7 @@ namespace SlangCapture entryPointCapture = m_mapEntryPointToCapture.tryGetValue(entryPoint); if (!entryPointCapture) { - entryPointCapture = new EntryPointCapture(entryPoint); + entryPointCapture = new EntryPointCapture(entryPoint, m_captureManager); Slang::ComPtr result(entryPointCapture); m_mapEntryPointToCapture.add(entryPoint, *result.detach()); } -- cgit v1.2.3