Cache and reuse glsl module. (#6152)

* Cache and reuse glsl module.

* Fix.

* Implement record/replay for the new api.

* Fix record replay.

* Fix test.

Author: csyonghe

docs/user-guide/08-compiling.md

@@ -589,12 +589,16 @@ A global session is created using the function `slang::createGlobalSession()`:
 using namespace slang;
 
 Slang::ComPtr<IGlobalSession> globalSession;
-createGlobalSession(globalSession.writeRef());
+SlangGlobalSessionDesc desc = {};
+createGlobalSession(&desc, globalSession.writeRef());
 ```
 
 When a global session is created, the Slang system will load its internal representation of the _core module_ that the compiler provides to user code.
 The core module can take a significant amount of time to load, so applications are advised to use a single global session if possible, rather than creating and then disposing of one for each compile.
 
+If you want to enable GLSL compatibility mode, you need to set `SlangGlobalSessionDesc::enableGLSL` to `true` when calling `createGlobalSession()`. This will load the necessary GLSL intrinsic module
+for compiling GLSL code. Without this setting, compiling GLSL code will result in an error.
+
 > #### Note ####
 > Currently, the global session type is *not* thread-safe.
 > Applications that wish to compile on multiple threads will need to ensure that each concurrent thread compiles with a distinct global session.
@@ -874,6 +878,7 @@ The only functions which are currently thread safe are
 ```C++
 SlangSession* spCreateSession(const char* deprecated);
 SlangResult slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession);
+SlangResult slang_createGlobalSession2(const SlangGlobalSessionDesc* desc, slang::IGlobalSession** outGlobalSession);
 SlangResult slang_createGlobalSessionWithoutCoreModule(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession);
 ISlangBlob* slang_getEmbeddedCoreModule();
 SlangResult slang::createGlobalSession(slang::IGlobalSession** outGlobalSession);

include/slang.h

@@ -3520,6 +3520,12 @@ struct SessionDesc;
 struct SpecializationArg;
 struct TargetDesc;
 
+enum class BuiltinModuleName
+{
+    Core,
+    GLSL
+};
+
 /** A global session for interaction with the Slang library.
 
 An application may create and re-use a single global session across
@@ -3750,6 +3756,36 @@ struct IGlobalSession : public ISlangUnknown
      */
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
     getSessionDescDigest(SessionDesc* sessionDesc, ISlangBlob** outBlob) = 0;
+
+    /** Compile from (embedded source) the builtin module on the session.
+    Will return a failure if there is already a builtin module available.
+    NOTE! API is experimental and not ready for production code.
+    @param module The builtin module name.
+    @param flags to control compilation
+    */
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    compileBuiltinModule(BuiltinModuleName module, CompileCoreModuleFlags flags) = 0;
+
+    /** Load a builtin module. Currently loads modules from the file system.
+    @param module The builtin module name
+    @param moduleData Start address of the serialized core module
+    @param sizeInBytes The size in bytes of the serialized builtin module
+
+    NOTE! API is experimental and not ready for production code
+    */
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    loadBuiltinModule(BuiltinModuleName module, const void* moduleData, size_t sizeInBytes) = 0;
+
+    /** Save the builtin module to the file system
+    @param module The builtin module name
+    @param archiveType The type of archive used to hold the builtin module
+    @param outBlob The serialized blob containing the builtin module
+
+    NOTE! API is experimental and not ready for production code  */
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveBuiltinModule(
+        BuiltinModuleName module,
+        SlangArchiveType archiveType,
+        ISlangBlob** outBlob) = 0;
 };
 
     #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid()
@@ -4429,6 +4465,32 @@ struct SpecializationArg
     // using.
     #define SLANG_API_VERSION 0
 
+enum SlangLanguageVersion
+{
+    SLANG_LANGUAGE_VERSION_2025 = 2025
+};
+
+
+/* Description of a Slang global session.
+ */
+struct SlangGlobalSessionDesc
+{
+    /// Size of this struct.
+    uint32_t structureSize = sizeof(SlangGlobalSessionDesc);
+
+    /// Slang API version.
+    uint32_t apiVersion = SLANG_API_VERSION;
+
+    /// Slang language version.
+    uint32_t languageVersion = SLANG_LANGUAGE_VERSION_2025;
+
+    /// Whether to enable GLSL support.
+    bool enableGLSL = false;
+
+    /// Reserved for future use.
+    uint32_t reserved[16] = {};
+};
+
 /* Create a global session, with the built-in core module.
 
 @param apiVersion Pass in SLANG_API_VERSION
@@ -4437,6 +4499,16 @@ struct SpecializationArg
 SLANG_EXTERN_C SLANG_API SlangResult
 slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession);
 
+
+/* Create a global session, with the built-in core module.
+
+@param desc Description of the global session.
+@param outGlobalSession (out)The created global session.
+*/
+SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSession2(
+    const SlangGlobalSessionDesc* desc,
+    slang::IGlobalSession** outGlobalSession);
+
 /* Create a global session, but do not set up the core module. The core module can
 then be loaded via loadCoreModule or compileCoreModule
 
@@ -4472,7 +4544,14 @@ namespace slang
 {
 inline SlangResult createGlobalSession(slang::IGlobalSession** outGlobalSession)
 {
-    return slang_createGlobalSession(SLANG_API_VERSION, outGlobalSession);
+    SlangGlobalSessionDesc defaultDesc = {};
+    return slang_createGlobalSession2(&defaultDesc, outGlobalSession);
+}
+inline SlangResult createGlobalSession(
+    const SlangGlobalSessionDesc* desc,
+    slang::IGlobalSession** outGlobalSession)
+{
+    return slang_createGlobalSession2(desc, outGlobalSession);
 }
 inline void shutdown()
 {

source/slang-record-replay/record/parameter-recorder.cpp

@@ -2,6 +2,14 @@
 
 namespace SlangRecord
 {
+void ParameterRecorder::recordStruct(SlangGlobalSessionDesc const& desc)
+{
+    recordUint32(desc.structureSize);
+    recordUint32(desc.apiVersion);
+    recordUint32(desc.languageVersion);
+    recordUint32(desc.enableGLSL);
+}
+
 void ParameterRecorder::recordStruct(slang::SessionDesc const& desc)
 {
     recordUint64(desc.structureSize);

source/slang-record-replay/record/parameter-recorder.h

@@ -40,7 +40,7 @@ class ParameterRecorder
     {
         recordValue(reinterpret_cast<SlangRecord::AddressFormat>(value));
     }
-
+    void recordStruct(SlangGlobalSessionDesc const& desc);
     void recordStruct(slang::SessionDesc const& desc);
     void recordStruct(slang::PreprocessorMacroDesc const& desc);
     void recordStruct(slang::CompilerOptionEntry const& entry);

source/slang-record-replay/record/slang-global-session.cpp

@@ -8,7 +8,9 @@
 namespace SlangRecord
 {
 // constructor is called in slang_createGlobalSession
-GlobalSessionRecorder::GlobalSessionRecorder(slang::IGlobalSession* session)
+GlobalSessionRecorder::GlobalSessionRecorder(
+    const SlangGlobalSessionDesc* desc,
+    slang::IGlobalSession* session)
     : m_actualGlobalSession(session)
 {
     SLANG_RECORD_ASSERT(m_actualGlobalSession != nullptr);
@@ -23,7 +25,10 @@ GlobalSessionRecorder::GlobalSessionRecorder(slang::IGlobalSession* session)
 
     ParameterRecorder* recorder{};
     {
-        m_recordManager->beginMethodRecord(ApiCallId::CreateGlobalSession, g_globalFunctionHandle);
+        recorder = m_recordManager->beginMethodRecord(
+            ApiCallId::CreateGlobalSession,
+            g_globalFunctionHandle);
+        recorder->recordStruct(*desc);
         recorder = m_recordManager->endMethodRecord();
     }
 
@@ -416,6 +421,70 @@ GlobalSessionRecorder::saveCoreModule(SlangArchiveType archiveType, ISlangBlob**
     return res;
 }
 
+SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::compileBuiltinModule(
+    slang::BuiltinModuleName module,
+    slang::CompileCoreModuleFlags flags)
+{
+    slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__);
+
+    ParameterRecorder* recorder{};
+    {
+        recorder = m_recordManager->beginMethodRecord(
+            ApiCallId::IGlobalSession_compileBuiltinModule,
+            m_globalSessionHandle);
+        recorder->recordEnumValue(module);
+        recorder->recordEnumValue(flags);
+        m_recordManager->endMethodRecord();
+    }
+
+    SlangResult res = m_actualGlobalSession->compileBuiltinModule(module, flags);
+    return res;
+}
+
+SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::loadBuiltinModule(
+    slang::BuiltinModuleName module,
+    const void* moduleData,
+    size_t sizeInBytes)
+{
+    slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__);
+
+    ParameterRecorder* recorder{};
+    {
+        recorder = m_recordManager->beginMethodRecord(
+            ApiCallId::IGlobalSession_loadBuiltinModule,
+            m_globalSessionHandle);
+        recorder->recordEnumValue(module);
+        recorder->recordPointer(moduleData, false, sizeInBytes);
+        m_recordManager->endMethodRecord();
+    }
+
+    SlangResult res = m_actualGlobalSession->loadBuiltinModule(module, moduleData, sizeInBytes);
+    return res;
+}
+SLANG_NO_THROW SlangResult SLANG_MCALL GlobalSessionRecorder::saveBuiltinModule(
+    slang::BuiltinModuleName module,
+    SlangArchiveType archiveType,
+    ISlangBlob** outBlob)
+{
+    slangRecordLog(LogLevel::Verbose, "%p: %s\n", m_actualGlobalSession.get(), __PRETTY_FUNCTION__);
+
+    ParameterRecorder* recorder{};
+    {
+        recorder = m_recordManager->beginMethodRecord(
+            ApiCallId::IGlobalSession_saveBuiltinModule,
+            m_globalSessionHandle);
+        recorder->recordEnumValue(module);
+        recorder->recordEnumValue(archiveType);
+        recorder = m_recordManager->endMethodRecord();
+    }
+    SlangResult res = m_actualGlobalSession->saveBuiltinModule(module, archiveType, outBlob);
+    {
+        recorder->recordAddress(*outBlob);
+        m_recordManager->apendOutput();
+    }
+    return res;
+}
+
 SLANG_NO_THROW SlangCapabilityID SLANG_MCALL GlobalSessionRecorder::findCapability(char const* name)
 {
     // No need to record this function. It's just a query function and it won't impact the internal

source/slang-record-replay/record/slang-global-session.h

@@ -14,7 +14,9 @@ using namespace Slang;
 class GlobalSessionRecorder : public RefObject, public slang::IGlobalSession
 {
 public:
-    explicit GlobalSessionRecorder(slang::IGlobalSession* session);
+    explicit GlobalSessionRecorder(
+        const SlangGlobalSessionDesc* desc,
+        slang::IGlobalSession* session);
 
     SLANG_REF_OBJECT_IUNKNOWN_ADD_REF
     SLANG_REF_OBJECT_IUNKNOWN_RELEASE
@@ -64,6 +66,18 @@ class GlobalSessionRecorder : public RefObject, public slang::IGlobalSession
     SLANG_NO_THROW SlangResult SLANG_MCALL
     saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob) override;
 
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL compileBuiltinModule(
+        slang::BuiltinModuleName module,
+        slang::CompileCoreModuleFlags flags) override;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadBuiltinModule(
+        slang::BuiltinModuleName module,
+        const void* moduleData,
+        size_t sizeInBytes) override;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveBuiltinModule(
+        slang::BuiltinModuleName module,
+        SlangArchiveType archiveType,
+        ISlangBlob** outBlob) override;
+
     SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(char const* name) override;
 
     SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerForTransition(

source/slang-record-replay/replay/decoder-consumer.h

@@ -11,7 +11,9 @@ namespace SlangRecord
 class IDecoderConsumer
 {
 public:
-    virtual void CreateGlobalSession(ObjectID outGlobalSessionId) = 0;
+    virtual void CreateGlobalSession(
+        SlangGlobalSessionDesc const& desc,
+        ObjectID outGlobalSessionId) = 0;
     virtual void IGlobalSession_createSession(
         ObjectID objectId,
         slang::SessionDesc const& desc,

source/slang-record-replay/replay/decoder-helper.cpp

@@ -54,6 +54,7 @@ size_t BlobDecoder::decode(const uint8_t* buffer, int64_t bufferSize)
     return readByte;
 }
 
+template class StructDecoder<SlangGlobalSessionDesc>;
 template class StructDecoder<slang::SessionDesc>;
 template class StructDecoder<slang::PreprocessorMacroDesc>;
 template class StructDecoder<slang::CompilerOptionEntry>;

source/slang-record-replay/replay/json-consumer.cpp

@@ -618,6 +618,24 @@ void JsonConsumer::_writeCompilerOptionEntryHelper(
     }
 }
 
+void JsonConsumer::_writeGlobalSessionDescHelper(
+    Slang::StringBuilder& builder,
+    int indent,
+    SlangGlobalSessionDesc const& desc,
+    Slang::String keyName,
+    bool isLastField)
+{
+    SLANG_UNUSED(isLastField);
+
+    ScopeWritterForKey scopeWritterForGlobalSessionDesc(&builder, &indent, keyName);
+    {
+        _writePair(builder, indent, "structureSize", (uint32_t)desc.structureSize);
+        _writePair(builder, indent, "apiVersion", (uint32_t)desc.apiVersion);
+        _writePair(builder, indent, "languageVersion", (uint32_t)desc.languageVersion);
+        _writePair(builder, indent, "enablGLSL", (uint32_t)desc.enableGLSL);
+    }
+}
+
 void JsonConsumer::_writeSessionDescHelper(
     Slang::StringBuilder& builder,
     int indent,
@@ -779,14 +797,17 @@ void JsonConsumer::_writeSessionDescHelper(
     }
 }
 
-void JsonConsumer::CreateGlobalSession(ObjectID outGlobalSessionId)
+void JsonConsumer::CreateGlobalSession(
+    SlangGlobalSessionDesc const& desc,
+    ObjectID outGlobalSessionId)
 {
     SANITY_CHECK();
     Slang::StringBuilder builder;
     int indent = 0;
 
     {
         ScopeWritterForKey scopeWritter(&builder, &indent, "IGlobalSession::createGlobalSession");
+        _writeGlobalSessionDescHelper(builder, indent, desc, "inDesc");
         _writePairNoComma(
             builder,
             indent,

source/slang-record-replay/replay/json-consumer.h

@@ -92,7 +92,9 @@ class JsonConsumer : public IDecoderConsumer, public Slang::RefObject
 public:
     JsonConsumer(const Slang::String& filePath);
     virtual ~JsonConsumer() = default;
-    virtual void CreateGlobalSession(ObjectID outGlobalSessionId);
+    virtual void CreateGlobalSession(
+        SlangGlobalSessionDesc const& desc,
+        ObjectID outGlobalSessionId);
     virtual void IGlobalSession_createSession(
         ObjectID objectId,
         slang::SessionDesc const& desc,
@@ -540,6 +542,12 @@ class JsonConsumer : public IDecoderConsumer, public Slang::RefObject
         slang::CompilerOptionEntry* compilerOptionEntries,
         uint32_t compilerOptionEntryCount,
         bool isLast = false);
+    static void _writeGlobalSessionDescHelper(
+        Slang::StringBuilder& builder,
+        int indent,
+        SlangGlobalSessionDesc const& globalSessionDesc,
+        Slang::String keyName,
+        bool isLast = false);
     static void _writeSessionDescHelper(
         Slang::StringBuilder& builder,
         int indent,