Allow using Rust to mimic RPSL.

CMakeLists.txt

@@ -29,8 +29,8 @@ else ( )
 endif ( )
 
 set( NugetPackagesRoot "${CMAKE_BINARY_DIR}/rps_nuget_packages" )
-set( DXAgilitySDK_VERSION_STRING "1.608.3" )
-set( DXAgilitySDK_VERSION 608 ) # to set D3D12SDKVersion
+set( DXAgilitySDK_VERSION_STRING "1.613.0" )
+set( DXAgilitySDK_VERSION 613 ) # to set D3D12SDKVersion
 set( DXAgilitySDK_INSTALL_DIR "${NugetPackagesRoot}/DXAgilitySDK.${DXAgilitySDK_VERSION_STRING}" )
 set( RpsDXAgilitySDK_DIR "${DXAgilitySDK_INSTALL_DIR}" CACHE STRING "DX12 Agility SDK directory" )
 
@@ -225,6 +225,12 @@ function( CompileRpslDxc TargetName RpslFileName GeneratedSource OutDirPrefix )
     set( ${GeneratedSource} "${OutputSource}" PARENT_SCOPE )
 endfunction()
 
+if ( WIN32 )
+    set( RpsRustCompilerBinaryDir "${PROJECT_SOURCE_DIR}/tools/rps_rustc/bin/win-x64/" )
+elseif ( RpsOsLinux )
+    set( RpsRustCompilerBinaryDir "${PROJECT_SOURCE_DIR}/tools/rps_rustc/bin/linux-x64/" )
+endif ( )
+
 # Copy assets
 function( CopyShaders TargetName ShaderFiles SrcFolder )
     foreach( Shader ${ShaderFiles} )

include/rps/runtime/common/rps_runtime.h

@@ -344,6 +344,15 @@ typedef RpsResult (*PFN_rpsRenderGraphBuild)(RpsRenderGraphBuilder hBuilder,
                                              const RpsConstant*    pArgs,
                                              uint32_t              numArgs);
 
+
+typedef RpsSubprogram (*PFN_rpsSelectDynamicSubprogram)(void* pContext, const RpsConstant* pArgs, uint32_t numArgs);
+
+typedef struct RpsSelectDynamicSubprogramCallback
+{
+    PFN_rpsSelectDynamicSubprogram pfnSelectDynamicSubprogram;
+    void*                          pUserContext;
+} RpsSelectDynamicSubprogramCallback;
+
 /// @brief Parameters for updating a render graph.
 ///
 /// @relates RpsRenderGraph
@@ -583,6 +592,11 @@ RpsResult rpsProgramBindNodeCallback(RpsSubprogram hProgram, const char* name, c
 /// @returns                        Result code of the operation. See <c><i>RpsResult</i></c> for more info.
 RpsResult rpsProgramBindNodeSubprogram(RpsSubprogram hProgram, const char* name, RpsSubprogram hSubprogram);
 
+
+RpsResult rpsProgramBindNodeDynamicProgram(RpsSubprogram                             hProgram,
+                                           const char*                               name,
+                                           const RpsSelectDynamicSubprogramCallback* pCallback);
+
 /// @} end addtogroup RpsSubprogram
 
 /// @addtogroup RpsRenderGraphRuntime
@@ -1089,6 +1103,8 @@ RpsResult rpsCmdSetCommandBuffer(const RpsCmdCallbackContext* pContext, RpsRunti
 /// @return                                     Result code of the operation. See <c><i>RpsResult</i></c> for more info.
 RpsResult rpsCmdGetNodeName(const RpsCmdCallbackContext* pContext, const char** ppNodeName, size_t* pNodeNameLength);
 
+RpsResult rpsCmdGetNodeDeclIndex(const RpsCmdCallbackContext* pContext, uint32_t* pNodeDeclIndex);
+
 /// @brief Gets the description of a node argument.
 ///
 /// @param pContext                             Pointer to the current command callback context. Must not be NULL.

src/core/rps_persistent_index_generator.hpp

@@ -21,10 +21,13 @@ namespace rps
             uint32_t numResources[NumResourceKinds];
             uint32_t localIndex;
             uint32_t numChildren;
+            uint32_t childrenIdBase;
 
             BlockInfo()
-                : localIndex(RPS_INDEX_NONE_U32)
+                : numResources{}
+                , localIndex(RPS_INDEX_NONE_U32)
                 , numChildren(0)
+                , childrenIdBase(RPS_INDEX_NONE_U32)
             {
             }
 
@@ -55,18 +58,20 @@ namespace rps
             : m_numIndicesTotal{}
             , m_blocks(&allocator)
             , m_blockStack(&allocator)
+            , m_blockInstanceStack(&allocator)
             , m_blockInstances(&allocator)
         {
         }
 
-        RpsResult EnterFunction(uint32_t                blockId,
-                                ConstArrayRef<uint32_t> resourceCounts,
+        RpsResult EnterFunction(ConstArrayRef<uint32_t> resourceCounts,
                                 uint32_t                localLoopIndex,
                                 uint32_t                numChildren)
         {
-            RPS_ASSERT(m_blockStack.empty());  // Currently everything is inlined.
+            uint32_t blockId = RPS_INDEX_NONE_U32;
+
+            RPS_V_RETURN(InitBlockInfo(&blockId, resourceCounts, localLoopIndex, numChildren));
 
-            InitBlockInfo(blockId, resourceCounts, localLoopIndex, numChildren);
+            RPS_CHECK_ALLOC(m_blockStack.push_back(blockId));
 
             RPS_ASSERT(m_blockInstances.empty() || (m_blockInstances.front().blockId == 0));
 
@@ -87,36 +92,51 @@ namespace rps
             return RPS_OK;
         }
 
-        RpsResult EnterLoop(uint32_t                blockId,
-                            ConstArrayRef<uint32_t> resourceCounts,
+        void BeginCallEntry()
+        {
+            m_blockStack.clear();
+        }
+
+        RpsResult EnterLoop(ConstArrayRef<uint32_t> resourceCounts,
                             uint32_t                localLoopIndex,
                             uint32_t                numChildren)
         {
-            RPS_V_RETURN(InitBlockInfo(blockId, resourceCounts, localLoopIndex, numChildren));
+            uint32_t blockId = RPS_INDEX_NONE_U32;
+
+            RPS_V_RETURN(InitBlockInfo(&blockId, resourceCounts, localLoopIndex, numChildren));
 
-            RPS_CHECK_ALLOC(m_blockStack.push_back(m_currentBlockInstanceId));
+            RPS_CHECK_ALLOC(m_blockStack.push_back(blockId));
+
+            RPS_CHECK_ALLOC(m_blockInstanceStack.push_back(m_currentBlockInstanceId));
 
             return RPS_OK;
         }
 
-        RpsResult ExitLoop(uint32_t blockId)
+        RpsResult ExitLoop()
         {
-            const uint32_t parentBlockInstance = m_blockStack.back();
+            RPS_RETURN_ERROR_IF(m_blockStack.empty(), RPS_ERROR_INVALID_PROGRAM);
 
             m_blockStack.pop_back();
 
+            const uint32_t parentBlockInstance = m_blockInstanceStack.back();
+            m_blockInstanceStack.pop_back();
+
             m_currentBlockInstanceId = parentBlockInstance;
 
             return RPS_OK;
         }
 
-        RpsResult LoopIteration(uint32_t blockId)
+        RpsResult LoopIteration()
         {
-            RPS_ASSERT(!m_blockStack.empty());
+            RPS_RETURN_ERROR_IF(m_blockStack.empty(), RPS_ERROR_INVALID_PROGRAM);
 
-            const uint32_t parentId        = m_blockStack.back();
+            RPS_ASSERT(!m_blockInstanceStack.empty());
+
+            const uint32_t parentId        = m_blockInstanceStack.back();
             const bool     bFirstIteration = (parentId == m_currentBlockInstanceId);
 
+            const uint32_t blockId = m_blockStack.back();
+
             const BlockInfo& currBlockInfo = m_blocks[blockId];
 
             uint32_t currBlockInstanceId = RPS_INDEX_NONE_U32;
@@ -157,6 +177,7 @@ namespace rps
 
             m_blocks.reset();
             m_blockStack.reset();
+            m_blockInstanceStack.reset();
             m_blockInstances.reset();
 
             m_currentBlockInstanceId = RPS_INDEX_NONE_U32;
@@ -168,6 +189,7 @@ namespace rps
 
             m_blocks.clear();
             m_blockStack.clear();
+            m_blockInstanceStack.clear();
             m_blockInstances.clear();
 
             m_currentBlockInstanceId = RPS_INDEX_NONE_U32;
@@ -187,14 +209,43 @@ namespace rps
         }
 
     private:
-        RpsResult InitBlockInfo(uint32_t                blockId,
+
+        RpsResult InitBlockInfo(uint32_t*               pBlockId,
                                 ConstArrayRef<uint32_t> resourceCounts,
                                 uint32_t                localLoopIndex,
                                 uint32_t                numChildren)
         {
-            if (blockId >= m_blocks.size())
+            uint32_t blockId = 0;
+
+            if (m_blockStack.empty())
+            {
+                RPS_RETURN_ERROR_IF(localLoopIndex != RPS_INDEX_NONE_U32, RPS_ERROR_INVALID_PROGRAM);
+
+                localLoopIndex = 0;
+
+                if (m_blocks.empty())
+                {
+                    m_blocks.reserve(1 + numChildren);
+                    m_blocks.resize(1, BlockInfo());
+                }
+            }
+            else
             {
-                m_blocks.resize(blockId + 1, BlockInfo());
+                const uint32_t parentBlockId = m_blockStack.back();
+
+                // Lazily alloc block range for children of the parent:
+
+                if (m_blocks[parentBlockId].childrenIdBase == RPS_INDEX_NONE_U32)
+                {
+                    const uint32_t numChildrenOfParent = m_blocks[parentBlockId].numChildren;
+
+                    m_blocks[parentBlockId].childrenIdBase = uint32_t(m_blocks.size());
+                    m_blocks.resize(m_blocks.size() + numChildrenOfParent, BlockInfo());
+                }
+
+                RPS_RETURN_ERROR_IF(localLoopIndex >= m_blocks[parentBlockId].numChildren, RPS_ERROR_INVALID_PROGRAM);
+
+                blockId = m_blocks[parentBlockId].childrenIdBase + localLoopIndex;
             }
 
             auto& blockInfo = m_blocks[blockId];
@@ -213,6 +264,8 @@ namespace rps
                                     RPS_ERROR_INVALID_PROGRAM);
             }
 
+            *pBlockId = blockId;
+
             return RPS_OK;
         }
 
@@ -265,6 +318,7 @@ namespace rps
 
         ArenaVector<BlockInfo>     m_blocks;
         ArenaVector<uint32_t>      m_blockStack;
+        ArenaVector<uint32_t>      m_blockInstanceStack;
         ArenaVector<BlockInstance> m_blockInstances;
 
         uint32_t m_currentBlockInstanceId = RPS_INDEX_NONE_U32;

src/runtime/common/phases/rps_access_dag_build.hpp

@@ -371,15 +371,18 @@ namespace rps
 
             AccessTransitionInfo transitionInfo;
 
+            const NodeId lastAccessor = accessState.accessorNodes.empty()
+                                            ? RPS_INDEX_NONE_U32
+                                            : accessState.accessorNodes.Get(m_nodeRefLists).back();
+
+            const bool bAccessedByCurrentNode = (lastAccessor == currNodeId);
+
             if ((accessState.lastTransition == RenderGraph::INVALID_TRANSITION) ||
-                NeedTransition(beforeAccess, newAccess, transitionInfo))
+                NeedTransition(beforeAccess, newAccess, transitionInfo, bAccessedByCurrentNode))
             {
                 // New Transition
-                NodeId lastAccessor = accessState.accessorNodes.empty()
-                                          ? RPS_INDEX_NONE_U32
-                                          : accessState.accessorNodes.Get(m_nodeRefLists).back();
 
-                if (lastAccessor != currNodeId)
+                if (!bAccessedByCurrentNode)
                 {
                     AddNewTransition(graph, currNodeId, accessState, newAccess, resourceId, range);
                 }
@@ -470,7 +473,8 @@ namespace rps
 
         inline bool NeedTransition(const RpsAccessAttr&  before,
                                    const RpsAccessAttr&  after,
-                                   AccessTransitionInfo& accessTransInfo) const
+                                   AccessTransitionInfo& accessTransInfo,
+                                   bool                  bAccessedByCurrentNode) const
         {
             // Coarse filter before calling runtime dependent CalculateAccessTransition:
             // TODO: Get this from runtime device
@@ -486,7 +490,8 @@ namespace rps
                 return accessTransInfo.bTransition;
             }
 
-            if (IsReadOnly(before) && IsReadOnly(after))
+            if ((IsReadOnly(before) && IsReadOnly(after)) ||
+                (bAccessedByCurrentNode && rpsAllBitsSet(before.accessFlags, after.accessFlags)))
             {
                 accessTransInfo.bMergedAccessStates = before != after;
                 accessTransInfo.mergedAccess        = before | after;

src/runtime/common/phases/rps_pre_process.hpp

@@ -281,6 +281,7 @@ namespace rps
                     pResInstance->InvalidateRuntimeResource(pRuntimeBackend);
                 }
                 pResInstance->isPendingInit = false;
+                pResInstance->isAccessed    = false;
 
                 pResInstance->SetInitialAccess(AccessAttr{});
 
@@ -356,6 +357,7 @@ namespace rps
 
                 ResourceInstance tempResInstCopy = parentResInstance;
                 tempResInstCopy.isTemporalSlice  = true;
+                tempResInstCopy.isAccessed       = false;
 
                 if (!bIsParentParamResource)
                 {
@@ -404,6 +406,11 @@ namespace rps
 
                 temporalSlice.SetInitialAccess(AccessAttr{});
                 temporalSlice.finalAccesses = {};
+
+                for (uint32_t iTemporalSlice = 0; iTemporalSlice < numTemporalLayers; iTemporalSlice++)
+                {
+                    resInstances[parentResInstance.temporalLayerOffset + iTemporalSlice].isAccessed = false;
+                }
             }
 
             return RPS_OK;
@@ -839,6 +846,8 @@ namespace rps
 
             accessInfo.resourceId = resInstanceId;
 
+            resInstance.isAccessed = true;
+
             bool bPendingRecreate = false;
 
             if (resInstance.desc.IsImage())

src/runtime/common/phases/rps_schedule_print.hpp

@@ -90,7 +90,7 @@ namespace rps
                     printer(" ]");
                 }
 
-                for (uint32_t iCmd = batchInfo.waitFencesBegin, cmdEnd = batchInfo.waitFencesBegin + batchInfo.numCmds;
+                for (uint32_t iCmd = batchInfo.cmdBegin, cmdEnd = batchInfo.cmdBegin + batchInfo.numCmds;
                      iCmd < cmdEnd;
                      iCmd++)
                 {

src/runtime/common/rps_render_graph.cpp

@@ -34,10 +34,9 @@ namespace rps
 
         if (pCreateInfo)
         {
-            (*ppRenderGraph)->OnInit(renderGraphCreateInfo);
+            RPS_V_RETURN((*ppRenderGraph)->OnInit(renderGraphCreateInfo));
         }
 
-
         if (pRuntimeDevice)
         {
             if ((*ppRenderGraph)->m_createInfo.numPhases == 0)
@@ -487,6 +486,17 @@ RpsResult rpsCmdGetNodeName(const RpsCmdCallbackContext* pContext, const char**
     return RPS_OK;
 }
 
+RpsResult rpsCmdGetNodeDeclIndex(const RpsCmdCallbackContext* pContext, uint32_t* pNodeDeclIndex)
+{
+    RPS_CHECK_ARGS(pContext && pNodeDeclIndex);
+
+    auto pBackendContext = rps::RuntimeCmdCallbackContext::Get(pContext);
+
+    *pNodeDeclIndex = pBackendContext->pCmdInfo->nodeDeclIndex;
+
+    return RPS_OK;
+}
+
 RpsResult rpsCmdGetParamDesc(const RpsCmdCallbackContext* pContext, RpsParamId paramId, RpsParameterDesc* pDesc)
 {
     RPS_CHECK_ARGS(pContext && pDesc);

src/runtime/common/rps_render_graph.hpp

@@ -65,6 +65,7 @@ namespace rps
         bool                    isAliased : 1;
         bool                    isPendingCreate : 1;
         bool                    isPendingInit : 1;
+        bool                    isAccessed : 1;
         bool                    isMutableFormat : 1;
         bool                    bBufferFormattedWrite : 1;
         bool                    bBufferFormattedRead : 1;